@nyte-ai/sdk 0.0.0-stage → 0.0.18

package/dist/chunks/capability-2q3s96kg.js

@@ -0,0 +1,57 @@
+// src/receipts.ts
+import { BatchOutcomeSchema, MoveOutcomeSchema, RunEndSchema, SdkError } from "@nyte-ai/schema";
+function receiptHandle2(rows, session, id, outcome) {
+  const input = { session, receipt: id };
+  return {
+    id,
+    async status() {
+      const status = await rows.call("receipt.status", input);
+      return status.kind === "settled" ? { kind: "settled", outcome: outcome(status.outcome) } : status;
+    },
+    async settled(options) {
+      return outcome(await rows.wait("receipt.settled", input, options));
+    },
+    async stop() {
+      const stopped = await rows.call("receipt.stop", input);
+      return stopped.kind === "settled" ? { kind: "settled", outcome: outcome(stopped.outcome) } : stopped;
+    }
+  };
+}
+function sendReceipt2(rows, session, id, message) {
+  return {
+    ...receiptHandle2(rows, session, id, sendOutcome),
+    message,
+    landed: () => rows.wait("receipt.landed", { session, receipt: id })
+  };
+}
+function runHandle2(rows, session, id) {
+  return {
+    id,
+    stop: () => rows.call("run.stop", { session, run: id }),
+    settled: (options) => rows.wait("run.settled", { session, run: id }, options)
+  };
+}
+function sendOutcome(value) {
+  if (typeof value === "object" && value !== null && "kind" in value && value.kind === "withdrawn")
+    return { kind: "withdrawn" };
+  const end = parsed2(RunEndSchema, value);
+  if (end !== null)
+    return end;
+  const moved = parsed2(MoveOutcomeSchema, value);
+  return moved !== null && moved.kind !== "moved" ? moved : unreadable("send");
+}
+function moveOutcome2(value) {
+  return parsed2(MoveOutcomeSchema, value) ?? unreadable("move");
+}
+function batchOutcome2(value) {
+  return parsed2(BatchOutcomeSchema, value) ?? unreadable("batch");
+}
+function parsed2(schema, value) {
+  const result = schema["~standard"].validate(value);
+  return result instanceof Promise || result.issues !== undefined ? null : result.value;
+}
+function unreadable(what) {
+  throw new SdkError("invalid", `The host answered a ${what} outcome the sdk cannot read.`);
+}
+
+export { receiptHandle2, sendReceipt2, runHandle2, moveOutcome2, batchOutcome2, parsed2 };

package/dist/chunks/capability-2wk9ktc5.js

@@ -0,0 +1,161 @@
+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]);
+      const ids = new Set(view.messages.map((message) => message.id));
+      shown.set(key, Math.max(shown.get(key) ?? 0, view.seq));
+      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-3qe1hz8t.js

@@ -0,0 +1,78 @@
+import {
+  pushed2
+} from "./capability-8hmez9nw.js";
+
+// src/history.ts
+function pagedViews2(head, options) {
+  let pages = [];
+  let turns = [];
+  let latest = null;
+  let shown = null;
+  let push = null;
+  let loading = null;
+  const show = (view) => {
+    const first = view.messages[0];
+    const before = shown?.messages ?? [];
+    const kept = first === undefined ? -1 : before.findIndex((message) => message.id === first.id);
+    pages = kept < 0 ? [] : before.slice(0, kept);
+    const paged = new Set(pages.map((message) => message.turn));
+    turns = (shown?.turns ?? []).filter((turn) => paged.has(turn.id));
+    latest = view;
+    shown = pages.length === 0 ? view : withPages(view, pages, turns);
+    push?.(shown);
+  };
+  const load = async (limit) => {
+    const oldest = shown?.messages[0];
+    if (oldest === undefined)
+      return 0;
+    const page = await head.history({ before: oldest.id, limit });
+    const current = latest;
+    if (page.messages.length === 0 || 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];
+    shown = withPages(current, pages, turns);
+    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, pages, turns) {
+  const own = new Set(view.turns.map((turn) => turn.id));
+  return {
+    ...view,
+    messages: [...pages, ...view.messages],
+    turns: [...turns.filter((turn) => !own.has(turn.id)), ...view.turns]
+  };
+}
+
+export { pagedViews2 };

package/dist/chunks/capability-591c8vr1.js

@@ -0,0 +1,134 @@
+import {
+  createSendJournal2
+} from "./capability-2wk9ktc5.js";
+import {
+  parsed2
+} from "./capability-2q3s96kg.js";
+import {
+  createClient2
+} from "./capability-cdz2rz6h.js";
+
+// src/connect.ts
+import { IdentityChallengeSchema, isJson, SdkError } from "@nyte-ai/schema";
+import { dev } from "@nyte-ai/core";
+import { createTransport, decodeError, decodeOutput } from "@nyte-ai/protocol";
+var paired = new Map;
+var encoder = new TextEncoder;
+async function connect2(options) {
+  const { credentials } = options;
+  const send = options.fetch ?? fetch;
+  const key = credentials.kind === "pairing" ? `${options.url}
+${credentials.code}` : null;
+  const kept = key === null ? undefined : paired.get(key);
+  const transport = createTransport({
+    url: options.url,
+    fetch: send,
+    headers: () => readCredentialHeaders(credentials, transport.credential() ?? kept ?? null)
+  });
+  if (options.expect !== undefined)
+    await verifyIdentity(options.url, send, options.expect.hostId);
+  const { view: first, frames } = await firstView(transport);
+  try {
+    return await openClient(options, transport, first, frames, key, kept);
+  } catch (error) {
+    await frames.return?.();
+    throw error;
+  }
+}
+async function openClient(options, transport, first, frames, key, kept) {
+  const { credentials } = options;
+  const answered = transport.host() ?? first.id;
+  if (options.expect !== undefined && (answered !== options.expect.hostId || first.id !== answered))
+    throw new SdkError("stale", `Host ${answered} answered instead of ${options.expect.hostId}.`, {
+      hostId: answered
+    });
+  const token = credentials.kind === "pairing" ? deviceToken(transport, kept) : null;
+  if (key !== null && token !== null)
+    paired.set(key, token);
+  const credential = token === null ? credentials : { kind: "token", token };
+  const journal = options.journal ?? createSendJournal2();
+  const journaled = await journal.load();
+  dev("sdk", "connected", {
+    hostId: first.id,
+    credential: credentials.kind,
+    journaled: journaled.length
+  });
+  return createClient2(transport, {
+    hostId: first.id,
+    principal: first.principal,
+    credential,
+    journal,
+    journaled,
+    hostFrames: frames
+  });
+}
+async function readCredentialHeaders(credentials, device) {
+  if (credentials.kind === "custom")
+    return credentials.headers();
+  if (credentials.kind === "token")
+    return { Authorization: `Bearer ${credentials.token}` };
+  return device === null ? { Authorization: `Pairing ${credentials.code}` } : { Authorization: `Bearer ${device}` };
+}
+function deviceToken(transport, kept) {
+  const token = transport.credential() ?? kept;
+  if (token === undefined)
+    throw new SdkError("unauthenticated", "The host returned no device credential for the pairing code.");
+  return token;
+}
+async function firstView(transport) {
+  const frames = transport.frames("connection.watch", {})[Symbol.asyncIterator]();
+  try {
+    const next = await frames.next();
+    if (next.done === true)
+      throw new SdkError("unavailable", "The host closed the connection before it answered.");
+    return {
+      view: decodeOutput("connection.watch", next.value),
+      frames: replayFirst(next.value, frames)
+    };
+  } catch (error) {
+    await frames.return?.();
+    throw error;
+  }
+}
+function replayFirst(first, rest) {
+  let replayed = false;
+  return {
+    async next() {
+      if (replayed)
+        return rest.next();
+      replayed = true;
+      return { done: false, value: first };
+    },
+    async return() {
+      await rest.return?.();
+      return { done: true, value: undefined };
+    }
+  };
+}
+async function verifyIdentity(url, send, expected) {
+  const nonce = crypto.randomUUID();
+  let response;
+  try {
+    response = await send(`${url.replace(/\/+$/, "")}/.nyte/identity?nonce=${encodeURIComponent(nonce)}`);
+  } catch (error) {
+    if (!(error instanceof TypeError))
+      throw error;
+    throw new SdkError("unavailable", error.message);
+  }
+  const body = await response.json().catch(() => null);
+  if (response.status === 404)
+    return;
+  if (!response.ok)
+    throw decodeError(isJson(body) ? body : null, response.status);
+  const challenge = parsed2(IdentityChallengeSchema, body);
+  if (challenge === null || challenge.nonce !== nonce)
+    throw new SdkError("invalid", "The host answered the identity challenge with something else.");
+  const key = await crypto.subtle.importKey("raw", Uint8Array.fromBase64(challenge.publicKey, { alphabet: "base64url" }), "Ed25519", false, ["verify"]);
+  const signed = await crypto.subtle.verify("Ed25519", key, Uint8Array.fromBase64(challenge.signature, { alphabet: "base64url" }), encoder.encode(`nyte/identity
+${challenge.hostId}
+${nonce}`));
+  if (!signed || challenge.hostId !== expected)
+    throw new SdkError("stale", signed ? `Host ${challenge.hostId} answered instead of ${expected}.` : `The identity signature of ${challenge.hostId} does not verify.`, { hostId: challenge.hostId });
+}
+
+export { connect2 };

package/dist/chunks/capability-8hmez9nw.js

@@ -0,0 +1,199 @@
+// src/watch.ts
+import { closable, coalesce } from "@nyte-ai/core";
+import { applyViewFrame } from "@nyte-ai/protocol";
+var DONE = { done: true, value: undefined };
+function createHeadViews2(rows) {
+  const open = new Map;
+  const start = (key, session, head, options) => {
+    const sinks = new Set;
+    let view = null;
+    const frames = rows.watch("head.watch", { session, head, options })[Symbol.asyncIterator]();
+    const finish = (end) => {
+      if (open.get(key) === hold)
+        open.delete(key);
+      for (const sink of sinks)
+        end(sink);
+    };
+    (async () => {
+      try {
+        for (;; ) {
+          const next = await frames.next();
+          if (next.done === true)
+            break;
+          const current = applyViewFrame(view, next.value);
+          view = current;
+          for (const sink of sinks)
+            sink.next(current);
+        }
+        finish((sink) => sink.end());
+      } catch (error) {
+        finish((sink) => sink.fail(error instanceof Error ? error : new Error(String(error))));
+      }
+    })();
+    const hold = {
+      view: () => view,
+      subscribe(sink) {
+        sinks.add(sink);
+        return () => {
+          sinks.delete(sink);
+          if (sinks.size > 0)
+            return;
+          if (open.get(key) === hold)
+            open.delete(key);
+          frames.return?.();
+        };
+      }
+    };
+    return hold;
+  };
+  return {
+    acquire(session, head, options) {
+      const key = JSON.stringify([session, head, options?.tail ?? null]);
+      const known = open.get(key);
+      if (known !== undefined)
+        return known;
+      const created = start(key, session, head, options);
+      open.set(key, created);
+      return created;
+    }
+  };
+}
+function watchHead2(views, journal, input) {
+  return coalesce(pushed2((sink) => {
+    const { session, head, options } = input;
+    const hold = views.acquire(session, head, options);
+    let shown = null;
+    const emit = () => {
+      const view = hold.view();
+      if (view === null)
+        return;
+      journal.landed(session, head, view);
+      const ids = new Set(view.messages.map((message) => message.id));
+      const next = withUnsent2(view, journal.unsent(session, head), (id) => ids.has(id));
+      if (next === shown)
+        return;
+      shown = next;
+      sink.next(next);
+    };
+    const leave = hold.subscribe({
+      next: emit,
+      end: () => sink.end(),
+      fail: (error) => sink.fail(error)
+    });
+    const unsubscribe = journal.subscribe(emit);
+    emit();
+    return () => {
+      unsubscribe();
+      leave();
+    };
+  }));
+}
+function watchHost2(rows, opened) {
+  return coalesce(pushed2((sink) => {
+    let view = null;
+    const frames = rows.watch("connection.watch", {}, opened)[Symbol.asyncIterator]();
+    (async () => {
+      try {
+        for (;; ) {
+          const next = await frames.next();
+          if (next.done === true)
+            break;
+          view = hostView(next.value, rows.link.current(), rows.operations());
+          sink.next(view);
+        }
+        sink.end();
+      } catch (error) {
+        sink.fail(error instanceof Error ? error : new Error(String(error)));
+      }
+    })();
+    const unsubscribe = rows.link.subscribe((link) => {
+      if (view !== null) {
+        view = { ...view, link };
+        sink.next(view);
+      }
+      if (link.kind === "closed")
+        sink.end();
+    });
+    return () => {
+      unsubscribe();
+      frames.return?.();
+    };
+  }));
+}
+function withUnsent2(view, unsent, known) {
+  const over = new Map(unsent.map((message) => [message.id, message]));
+  const missing = unsent.filter((message) => !known(message.id));
+  if (missing.length === 0 && !view.messages.some((message) => over.has(message.id)))
+    return view;
+  const messages = view.messages.map((message) => over.get(message.id) ?? message);
+  const at = messages.findIndex((message) => message.kind === "user" && message.status.kind === "pending");
+  const index = at < 0 ? messages.length : at;
+  return {
+    ...view,
+    messages: [...messages.slice(0, index), ...missing, ...messages.slice(index)]
+  };
+}
+function hostView(wire, link, operations) {
+  return {
+    id: wire.id,
+    link,
+    operations,
+    name: wire.name,
+    platform: wire.platform,
+    version: wire.version,
+    catalog: wire.catalog,
+    plugins: wire.plugins,
+    settings: wire.settings,
+    defaultWorkspace: wire.defaultWorkspace,
+    authority: new Set(wire.authority)
+  };
+}
+function pushed2(start) {
+  return closable(() => {
+    let slot = null;
+    let ending = null;
+    let wake = null;
+    const signal = () => {
+      const resolve = wake;
+      wake = null;
+      resolve?.();
+    };
+    const stop = start({
+      next(value) {
+        if (ending !== null)
+          return;
+        slot = { value };
+        signal();
+      },
+      end() {
+        ending ??= "ended";
+        signal();
+      },
+      fail(error) {
+        ending ??= { error };
+        signal();
+      }
+    });
+    return {
+      async pull() {
+        for (;; ) {
+          const held = slot;
+          if (held !== null) {
+            slot = null;
+            return { done: false, value: held.value };
+          }
+          if (ending === "ended")
+            return DONE;
+          if (ending !== null)
+            throw ending.error;
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        }
+      },
+      close: stop
+    };
+  });
+}
+
+export { createHeadViews2, watchHead2, watchHost2, withUnsent2, pushed2 };

package/dist/chunks/capability-9747w1b1.js

@@ -0,0 +1,55 @@
+// src/part.ts
+import { asId, isJson, SdkError } from "@nyte-ai/schema";
+import { callable, fitsActionOutput, fitsAnswer, fitsState } from "@nyte-ai/core";
+function partHandle2(rows, session, id, kind) {
+  return {
+    id,
+    async update(next, options) {
+      const given = callable(next) ? await derived(rows, session, id, kind, next) : { value: next };
+      if (given === null)
+        return { kind: "missing" };
+      if (!isJson(given.value))
+        return { kind: "invalid", issues: [issue("The state is not JSON.")] };
+      return rows.call("part.update", { session, part: id, next: given.value, options });
+    },
+    async act(action, input) {
+      const named = String(action);
+      if (!isJson(input))
+        throw new SdkError("invalid", `The input of ${named} is not JSON.`);
+      const outcome = await rows.call("part.act", { session, part: id, action: named, input });
+      if (outcome.kind !== "ok")
+        return outcome;
+      const absent = outcome.output === null ? undefined : outcome.output;
+      if (fitsActionOutput(kind, action, absent))
+        return { kind: "ok", output: absent };
+      if (fitsActionOutput(kind, action, outcome.output))
+        return { kind: "ok", output: outcome.output };
+      return { kind: "failed", message: `This handle cannot carry ${named}'s output.` };
+    },
+    async answer(options) {
+      try {
+        const answer = await rows.wait("part.answer", { session, part: id }, options);
+        return answer !== null && fitsAnswer(kind, answer) ? answer : null;
+      } catch (error) {
+        if (options?.signal?.aborted === true)
+          return null;
+        throw error;
+      }
+    },
+    async close() {
+      await rows.call("part.close", { session, part: id });
+    }
+  };
+}
+async function derived(rows, session, id, kind, next) {
+  const view = await rows.call("head.view", { session, head: asId("main") });
+  const current = view.parts.find((part) => part.id === id) ?? view.messages.find((message) => message.kind === "part" && message.part === id);
+  if (current === undefined)
+    return null;
+  return fitsState(kind, current.state) ? { value: next(current.state) } : null;
+}
+function issue(message) {
+  return { severity: "error", path: [], message };
+}
+
+export { partHandle2 };