@nyte-ai/sdk 0.0.0-stage → 0.0.18

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-cdz2rz6h.js

@@ -0,0 +1,208 @@
+import {
+  createHeadViews2,
+  watchHead2,
+  watchHost2,
+  withUnsent2
+} from "./capability-8hmez9nw.js";
+import {
+  createLink2,
+  createRows2
+} from "./capability-artgq59v.js";
+import {
+  journalLoop2
+} from "./capability-2wk9ktc5.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-y1amted3.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 }),
+      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);
+      const ids = new Set(view.messages.map((message) => message.id));
+      return withUnsent2(view, journal.unsent(session, head), (id) => ids.has(id));
+    },
+    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-esdwn315.js

@@ -0,0 +1,26 @@
+// src/paint-spans.ts
+import { followedTrace, startSpan, tracing } from "@nyte-ai/core";
+function tracePaints2(views, session, painted) {
+  return tracing.enabled ? timed(views, session, painted) : views;
+}
+async function* timed(views, session, painted) {
+  let shown = null;
+  for await (const view of views) {
+    const ids = new Set(view.messages.map((message) => message.id));
+    const followed = followedTrace(session);
+    for (const message of view.messages) {
+      if (shown === null ? message.id !== followed : shown.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 = ids;
+    yield view;
+  }
+}
+
+export { tracePaints2 };

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