@nyte-ai/sdk 0.0.0-stage → 0.0.19

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-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 };

package/dist/chunks/capability-agj3gwwv.js

@@ -0,0 +1,134 @@
+import {
+  createSendJournal2
+} from "./capability-ke5yk1as.js";
+import {
+  parsed2
+} from "./capability-2q3s96kg.js";
+import {
+  createClient2
+} from "./capability-ec663cyt.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-artgq59v.js

@@ -0,0 +1,232 @@
+// src/rows.ts
+import { SdkError } from "@nyte-ai/schema";
+import { closable, dev } from "@nyte-ai/core";
+import { decodeOutput, encodeInput } from "@nyte-ai/protocol";
+var DONE = { done: true, value: undefined };
+var FIRST_DELAY_MS = 50;
+var BASE_DELAY_MS = 250;
+var MAX_DELAY_MS = 1e4;
+function createLink2() {
+  let state = { kind: "connected" };
+  const listeners = new Set;
+  const controller = new AbortController;
+  const publish = (next) => {
+    state = next;
+    for (const listener of listeners)
+      listener(next);
+  };
+  return {
+    current: () => state,
+    lost() {
+      if (state.kind === "closed")
+        return;
+      publish(state.kind === "reconnecting" ? { ...state, attempts: state.attempts + 1 } : { kind: "reconnecting", since: Date.now(), attempts: 1 });
+    },
+    restored() {
+      if (state.kind === "reconnecting")
+        publish({ kind: "connected" });
+    },
+    close(reason) {
+      if (state.kind === "closed")
+        return;
+      dev("sdk", "link closed", { reason });
+      publish({ kind: "closed", reason });
+      controller.abort(new SdkError("unavailable", "The connection is closed."));
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    signal: controller.signal
+  };
+}
+function createRows2(transport, link) {
+  const request = async (send, signal) => {
+    link.signal.throwIfAborted();
+    try {
+      const answer = await send(signal === undefined ? link.signal : AbortSignal.any([link.signal, signal]));
+      link.restored();
+      return answer;
+    } catch (error) {
+      if (hostGone(transport, error))
+        link.close("host-gone");
+      link.signal.throwIfAborted();
+      if (linkLost(error))
+        link.lost();
+      if (error instanceof SdkError && error.code === "unauthenticated")
+        link.close("revoked");
+      throw error;
+    }
+  };
+  const call = async (name, input, options) => decodeOutput(name, await request((signal) => transport.invoke(name, encodeInput(name, input), { signal }), options?.signal));
+  return {
+    link,
+    operations: () => transport.operations(),
+    call,
+    async wait(name, input, options) {
+      for (let attempts = 1;; attempts += 1) {
+        try {
+          return await call(name, input, options);
+        } catch (error) {
+          if (!linkLost(error) || link.signal.aborted || options?.signal?.aborted === true)
+            throw error;
+          dev("sdk", "wait retrying", { name, attempts });
+          await backoff2(link, retryDelay2(attempts), options?.signal === undefined ? link.signal : AbortSignal.any([link.signal, options.signal]));
+          options?.signal?.throwIfAborted();
+        }
+      }
+    },
+    async upload(name, input, body) {
+      return decodeOutput(name, await request((signal) => transport.upload(name, encodeInput(name, input), body, { signal }), undefined));
+    },
+    bytes: (name, input, options) => request((signal) => transport.bytes(name, encodeInput(name, input), { signal }), options?.signal),
+    frames: (name, input) => through(transport.frames(name, encodeInput(name, input)), (frame) => decoded(name, frame), link.signal),
+    watch: (name, input, opened) => resumable(transport, link, name, encodeInput(name, input), opened),
+    output: (input) => through(transport.output(encodeInput("job.output", input)), (frame) => frame.kind === "bytes" ? { value: frame } : decoded("job.output", frame), link.signal)
+  };
+}
+function resumable(transport, link, name, input, opened) {
+  return closable(() => {
+    const stop = new AbortController;
+    const signal = AbortSignal.any([stop.signal, link.signal]);
+    let frames = opened ?? null;
+    let attempts = 0;
+    let reopened = false;
+    const release = () => {
+      frames?.return?.();
+    };
+    signal.addEventListener("abort", release, { once: true });
+    return {
+      async pull() {
+        for (;; ) {
+          if (signal.aborted)
+            return DONE;
+          const current = frames ?? transport.frames(name, input)[Symbol.asyncIterator]();
+          frames = current;
+          let next = DONE;
+          try {
+            next = await current.next();
+          } catch (error) {
+            if (hostGone(transport, error)) {
+              link.close("host-gone");
+              return DONE;
+            }
+            if (error instanceof SdkError && error.code === "unauthenticated") {
+              link.close("revoked");
+              return DONE;
+            }
+            if (!linkLost(error))
+              throw error;
+          }
+          if (next.done !== true) {
+            if (attempts > 0) {
+              dev("sdk", "watch resumed", { name, attempts });
+              link.restored();
+            }
+            attempts = 0;
+            const value = decoded(name, next.value);
+            if (value !== null) {
+              reopened = false;
+              return { done: false, value: value.value };
+            }
+            if (reopened)
+              throw new SdkError("invalid", `The host sends ${name} frames this client cannot read.`);
+            reopened = true;
+            frames = null;
+            current.return?.();
+            dev("sdk", "watch reopened", { name });
+            continue;
+          }
+          frames = null;
+          if (signal.aborted)
+            return DONE;
+          attempts += 1;
+          dev("sdk", "watch reconnecting", { name, attempts });
+          link.lost();
+          await backoff2(link, retryDelay2(attempts), signal);
+        }
+      },
+      close() {
+        signal.removeEventListener("abort", release);
+        stop.abort();
+        release();
+      }
+    };
+  });
+}
+function through(source, map, signal) {
+  return {
+    [Symbol.asyncIterator]() {
+      const iterator = source[Symbol.asyncIterator]();
+      const stop = () => {
+        iterator.return?.();
+      };
+      signal.addEventListener("abort", stop, { once: true });
+      return {
+        async next() {
+          for (;; ) {
+            if (signal.aborted)
+              return DONE;
+            const next = await iterator.next();
+            if (next.done === true) {
+              signal.removeEventListener("abort", stop);
+              return DONE;
+            }
+            const mapped = map(next.value);
+            if (mapped !== null)
+              return { done: false, value: mapped.value };
+          }
+        },
+        async return() {
+          signal.removeEventListener("abort", stop);
+          await iterator.return?.();
+          return DONE;
+        }
+      };
+    }
+  };
+}
+function decoded(name, data) {
+  try {
+    return { value: decodeOutput(name, data) };
+  } catch (error) {
+    if (!(error instanceof SdkError) || error.code !== "invalid")
+      throw error;
+    dev("sdk", "frame skipped", { name, message: error.message });
+    return null;
+  }
+}
+function hostGone(transport, error) {
+  const pinned = transport.host();
+  return error instanceof SdkError && error.code === "stale" && pinned !== null && error.hostId !== null && error.hostId !== pinned;
+}
+function linkLost(error) {
+  return error instanceof SdkError && error.code === "unavailable";
+}
+function retryDelay2(attempts) {
+  return attempts <= 1 ? FIRST_DELAY_MS : Math.min(BASE_DELAY_MS * 2 ** (attempts - 2), MAX_DELAY_MS);
+}
+function backoff2(link, ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      unsubscribe();
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+    const unsubscribe = link.subscribe((state) => {
+      if (state.kind === "connected")
+        done();
+    });
+  });
+}
+
+export { createLink2, createRows2, retryDelay2, backoff2 };

package/dist/chunks/capability-b52hty54.js

@@ -0,0 +1,17 @@
+// src/surface.ts
+import { dev as dev2, watchStore as watchStore2 } from "@nyte-ai/core";
+import {
+  clearSpans as clearSpans2,
+  enableTracing as enableTracing2,
+  followTrace as followTrace2,
+  followedTrace as followedTrace2,
+  readSpans as readSpans2,
+  SPAN_NAMES as SPAN_NAMES2,
+  startSpan as startSpan2,
+  traced as traced2,
+  tracing as tracing2
+} from "@nyte-ai/core";
+import { SdkError as SdkError2 } from "@nyte-ai/schema";
+import { operationsDigest as operationsDigest2 } from "@nyte-ai/protocol";
+
+export { dev2, watchStore2, clearSpans2, enableTracing2, followTrace2, followedTrace2, readSpans2, SPAN_NAMES2, startSpan2, traced2, tracing2, SdkError2, operationsDigest2 };

package/dist/chunks/capability-ctnsbfx9.js

@@ -0,0 +1,203 @@
+// 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 next = withUnsent2(view, journal.unsent(session, head));
+      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) {
+  const lead = view.leadingPrompt?.id;
+  const held = unsent.filter((message) => message.id !== lead);
+  if (held.length === 0)
+    return view;
+  const over = new Map(held.map((message) => [message.id, message]));
+  const known = new Set(view.messages.map((message) => message.id));
+  const missing = held.filter((message) => !known.has(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 };