@nyte-ai/core 0.0.18 → 0.0.21

package/dist/chunks/{compose-amr0k1m1.js → compose-b2bf1jvy.js}

@@ -4,10 +4,6 @@ import {
 import {
   lineDiff2
 } from "./compose-j50h13pg.js";
-import {
-  followedTrace2,
-  traceparent2
-} from "./compose-sd0stm97.js";
 
 // src/builtins/environment.ts
 import { PatchEntrySchema, standard, writePatch } from "@nyte-ai/schema";
@@ -17,6 +13,7 @@ var READ_CHARS = 50 * 1024;
 var LIST_LIMIT = 500;
 var SHELL_BYTES = 32 * 1024;
 var PROGRESS_BYTES = 4 * 1024;
+var FIRST_OUTPUT_MS = 1000;
 var MIME_TYPES = new Map([
   ["png", "image/png"],
   ["jpg", "image/jpeg"],
@@ -49,7 +46,16 @@ var listParameters = standard(Type.Object({
 }));
 var bashParameters = standard(Type.Object({
   command: Type.String({ description: "The shell command to run." }),
-  description: Type.Optional(Type.String({ description: "What the command does, in a few words, for the user." }))
+  description: Type.Optional(Type.String({ description: "What the command does, in a few words, for the user." })),
+  background: Type.Optional(Type.Boolean({
+    description: "Start the command and return a job id with its first output instead of waiting for it to exit. Use for servers, watchers, and other long-lived commands, without a trailing &. The command keeps running across turns, and you are told when it exits; read its output or stop it with the job tool. Do not use it to speed up ordinary commands."
+  }))
+}));
+var jobParameters = standard(Type.Object({
+  id: Type.String({ description: "The job id a background bash call returned." }),
+  action: Type.Enum(["output", "stop"], {
+    description: "output reads the job's state and latest output; stop ends it."
+  })
 }));
 var read = {
   name: "read",
@@ -79,7 +85,7 @@ var write = {
   parameters: writeParameters,
   output: PatchEntrySchema,
   class: (args) => ({ kind: "edit", path: args.path }),
-  replay: "safe",
+  replay: "never",
   async execute(args, invocation) {
     const { files } = invocation.env;
     const previous = await files.read(args.path);
@@ -99,7 +105,7 @@ var edit = {
   parameters: editParameters,
   output: PatchEntrySchema,
   class: (args) => ({ kind: "edit", path: args.path }),
-  replay: "safe",
+  replay: "never",
   async execute(args, invocation) {
     const { files } = invocation.env;
     const document = await files.read(args.path);
@@ -177,44 +183,119 @@ var bash = {
   class: (args) => args.description === undefined ? { kind: "shell", command: args.command } : { kind: "shell", command: args.command, description: args.description },
   replay: "never",
   async execute(args, invocation) {
-    const { env } = invocation;
-    const trace = followedTrace2(invocation.session.id);
-    const job = await env.exec(args.command, {
-      cwd: env.cwd,
-      signal: invocation.signal,
-      env: trace === null ? undefined : { TRACEPARENT: traceparent2(trace) }
+    const { foreground, signal } = invocation;
+    const running = await foreground.start({
+      command: args.command,
+      title: args.description ?? args.command
     });
-    const chunks = [];
-    let kept = 0;
-    let dropped = 0;
-    let code = null;
-    for await (const frame of job.output()) {
-      if (frame.kind === "exit") {
-        code = frame.code;
-        break;
-      }
-      if (frame.kind === "gap")
-        continue;
-      chunks.push(frame.data);
-      kept += frame.data.byteLength;
-      while (kept - (chunks[0]?.byteLength ?? 0) >= SHELL_BYTES && chunks.length > 1) {
-        const first = chunks.shift();
-        kept -= first?.byteLength ?? 0;
-        dropped += first?.byteLength ?? 0;
+    const stop = () => void running.stop().catch(() => {
+      return;
+    });
+    signal.addEventListener("abort", stop, { once: true });
+    if (signal.aborted)
+      stop();
+    const shell = createShellOutput((tail) => invocation.progress({ text: tail }));
+    const frames = running.output()[Symbol.asyncIterator]();
+    try {
+      const exited = await shell.read(frames, args.background === true ? AbortSignal.any([foreground.released, AbortSignal.timeout(FIRST_OUTPUT_MS)]) : foreground.released);
+      if (!exited && (foreground.released.aborted || foreground.release())) {
+        await frames.return?.();
+        return text(shell.render(`[running in the background as job ${running.id}: you are told when it exits; the job tool reads its output or stops it]`));
       }
-      invocation.progress({ text: decodeOutputTail(chunks, PROGRESS_BYTES) });
+      if (!exited)
+        await shell.read(frames, new AbortController().signal);
+      const end = await running.settled();
+      const exit = end.kind === "exited" ? end.code ?? shell.code() : shell.code();
+      return text(shell.render(end.kind === "lost" ? "[the process was lost]" : `[exit code ${exit ?? "none"}${end.reason === "exited" ? "" : `, ${end.reason}`}]`));
+    } catch (error) {
+      stop();
+      throw error;
+    } finally {
+      signal.removeEventListener("abort", stop);
     }
-    const end = await job.settled();
-    const exit = end.kind === "exited" ? end.code ?? code : code;
-    const joined = joinBytes(chunks);
-    const cut = Math.max(0, joined.byteLength - SHELL_BYTES);
-    const output = new TextDecoder().decode(joined.subarray(cut)).trimEnd();
-    const truncated = dropped + cut > 0 ? [`[truncated: the first ${dropped + cut} bytes of output are not shown]`] : [];
-    const status = end.kind === "lost" ? "[the process was lost]" : `[exit code ${exit ?? "none"}${end.reason === "exited" ? "" : `, ${end.reason}`}]`;
-    return text([...truncated, ...output === "" ? [] : [output], status].join(`
-`));
   }
 };
+var job = {
+  name: "job",
+  description: "Read the state and latest output of a job a background bash call started, or stop it.",
+  parameters: jobParameters,
+  class: (args) => ({
+    kind: "custom",
+    label: args.action === "stop" ? `Stopping job ${args.id}` : `Reading job ${args.id}`
+  }),
+  effects: "none",
+  replay: "safe",
+  async execute(args, invocation) {
+    const { jobs } = invocation.workspace;
+    const find = async () => (await jobs.list()).find((view) => view.id === args.id && view.session === invocation.session.id);
+    const found = await find();
+    if (found === undefined)
+      return text(`This chat has no job ${args.id}.`);
+    if (args.action === "stop")
+      await invocation.workspace.job(found.id).stop();
+    const view = args.action === "stop" ? await find() ?? found : found;
+    const tail = view.tail.trimEnd();
+    const state = describeJobState(view.state);
+    return text(tail === "" ? `Job ${view.id} ${state}.` : `Job ${view.id} ${state}:
+${tail}`);
+  }
+};
+function describeJobState(state) {
+  if (state.kind === "running")
+    return "is running";
+  if (state.kind === "lost")
+    return "was lost with the host";
+  return state.reason === "exited" ? `exited with code ${state.code ?? "none"}` : `ended (${state.reason}) with code ${state.code ?? "none"}`;
+}
+function createShellOutput(progress) {
+  const chunks = [];
+  let kept = 0;
+  let dropped = 0;
+  let code = null;
+  let pending = null;
+  return {
+    async read(frames, until) {
+      const detached = new Promise((resolve) => {
+        if (until.aborted)
+          resolve(null);
+        until.addEventListener("abort", () => resolve(null), { once: true });
+      });
+      for (;; ) {
+        pending ??= frames.next();
+        const next = await Promise.race([pending, detached]);
+        if (next === null)
+          return false;
+        pending = null;
+        if (next.done === true)
+          return true;
+        const frame = next.value;
+        if (frame.kind === "exit") {
+          code = frame.code;
+          return true;
+        }
+        if (frame.kind === "gap")
+          continue;
+        chunks.push(frame.data);
+        kept += frame.data.byteLength;
+        while (kept - (chunks[0]?.byteLength ?? 0) >= SHELL_BYTES && chunks.length > 1) {
+          const first = chunks.shift();
+          kept -= first?.byteLength ?? 0;
+          dropped += first?.byteLength ?? 0;
+        }
+        progress(decodeOutputTail(chunks, PROGRESS_BYTES));
+      }
+    },
+    code: () => code,
+    render(status) {
+      const joined = joinBytes(chunks);
+      const cut = Math.max(0, joined.byteLength - SHELL_BYTES);
+      const output = new TextDecoder().decode(joined.subarray(cut)).trimEnd();
+      const truncated = dropped + cut > 0 ? [`[truncated: the first ${dropped + cut} bytes of output are not shown]`] : [];
+      return [...truncated, ...output === "" ? [] : [output], status].join(`
+`);
+    }
+  };
+}
 function joinBytes(chunks) {
   const joined = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
   let offset = 0;
@@ -241,7 +322,7 @@ function decodeOutputTail(chunks, limit) {
 }
 var environmentPlugin2 = {
   id: "environment",
-  contribute: { tools: [read, write, edit, list, bash] },
+  contribute: { tools: [read, write, edit, list, bash, job] },
   activate(api) {
     const cwd = tryReadCwd(() => api.env);
     if (cwd !== null)

package/dist/chunks/{compose-xpfr4wt3.js → compose-bbhk8vnr.js}

@@ -2,7 +2,7 @@ import {
   liveRef2,
   receiptRef2,
   callRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   dev2
 } from "./compose-n116fnmp.js";
@@ -10,10 +10,10 @@ import {
   readRefExpectation2,
   put2,
   readCall2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   publishSet2
-} from "./compose-7b8ajk7a.js";
+} from "./compose-ad80nkkn.js";
 
 // src/fold/commit.ts
 import { SdkError } from "@nyte-ai/schema";
@@ -32,7 +32,10 @@ async function writeReceipt2(kernel, session, record) {
     throw new SdkError("stale", `Receipt ${record.id} already exists.`);
 }
 async function commit2(kernel, updates, under = null) {
-  const fenced = under === null ? updates : updates.map((update) => ({ ...update, fence: liveRef2(under.session, under.run) }));
+  const fenced = under === null ? updates : updates.map((update) => ({
+    ...update,
+    fences: [...update.fences ?? [], liveRef2(under.session, under.run)]
+  }));
   const outcome = await kernel.store.refs.set(fenced);
   dev2("store", "refs.set", { names: updates.map(({ name }) => name), outcome });
   if (outcome.kind === "fenced" && under !== null)

package/dist/chunks/compose-bd8c5n7k.js

@@ -0,0 +1,32 @@
+import {
+  decodeRunRecord2
+} from "./compose-gxjc6vz9.js";
+import {
+  runRef2
+} from "./compose-cqpjcx2t.js";
+import {
+  load2
+} from "./compose-vn7b7fdj.js";
+
+// src/engine/surface.ts
+var NONE = new Set;
+async function readRequires(kernel, session, run) {
+  const found = await load2(kernel.store, await kernel.store.refs.get(runRef2(session, run)), decodeRunRecord2);
+  return found?.record.requires;
+}
+async function hiddenOwners2(kernel, session, run) {
+  const mine = kernel.presence?.member.capabilities ?? [];
+  if (mine.length === 0 || run === null)
+    return NONE;
+  const requires = await readRequires(kernel, session, run);
+  return requires === undefined ? NONE : new Set(mine.filter((owner) => !requires.includes(owner)));
+}
+async function missingCapabilities2(kernel, session, run) {
+  if (run === null)
+    return [];
+  const mine = kernel.presence?.member.capabilities ?? [];
+  const requires = await readRequires(kernel, session, run) ?? [];
+  return requires.filter((capability) => !mine.includes(capability));
+}
+
+export { hiddenOwners2, missingCapabilities2 };

package/dist/chunks/{compose-rehp8epe.js → compose-byse0eqj.js}

@@ -1,9 +1,9 @@
 import {
   decodePartRecord2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   partRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   dev2
 } from "./compose-n116fnmp.js";
@@ -11,17 +11,17 @@ import {
   load2,
   put2,
   readCall2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   storedAnswer2
-} from "./compose-drdej9yt.js";
+} from "./compose-d95fwwvw.js";
 import {
   waitIndex2,
   wokenIndex2
 } from "./compose-0wq555bd.js";
 import {
   changeCall2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-bbhk8vnr.js";
 import {
   holdLease2
 } from "./compose-vzvm76dn.js";
@@ -30,7 +30,7 @@ import {
   readParkedWait2,
   waitingOn2,
   lapsed2
-} from "./compose-ef936rsa.js";
+} from "./compose-bz70g01d.js";
 
 // src/engine/durable.ts
 import { isJson, isJsonObject, SdkError } from "@nyte-ai/schema";
@@ -88,7 +88,7 @@ async function runStep2(kernel, input) {
     dev2("durable", "replayed", { session, call });
     return { kind: "done", value: read(record.result) };
   }
-  if (!opened.wrote && input.replay === "never") {
+  if (!opened.wrote && record.replay === "never") {
     return { kind: "interrupted", value: await settle({ kind: "interrupted" }) };
   }
   const writes = [];

package/dist/chunks/{compose-ef936rsa.js → compose-bz70g01d.js}

@@ -1,13 +1,15 @@
 import {
   decodeRunRecord2,
   decodePartRecord2,
-  decodeCallRecord2
-} from "./compose-1jz2j92f.js";
+  decodeCallRecord2,
+  decodeJobRecord2
+} from "./compose-gxjc6vz9.js";
 import {
   runRef2,
   partRef2,
-  callRef2
-} from "./compose-kb22bkpt.js";
+  callRef2,
+  jobRef2
+} from "./compose-cqpjcx2t.js";
 import {
   dev2
 } from "./compose-n116fnmp.js";
@@ -15,10 +17,10 @@ import {
   load2,
   put2,
   readCall2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   storedAnswer2
-} from "./compose-drdej9yt.js";
+} from "./compose-d95fwwvw.js";
 import {
   WAITS2,
   TIME2,
@@ -33,10 +35,10 @@ import {
 import {
   commit2,
   changeCall2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-bbhk8vnr.js";
 import {
   readRunEnd2
-} from "./compose-6vf6dkk2.js";
+} from "./compose-xhtgytrh.js";
 
 // src/engine/waits.ts
 import { asId, SdkError } from "@nyte-ai/schema";
@@ -141,8 +143,8 @@ function createWaitRegistry2(kernel, rerunAction) {
         return answer === null ? null : { kind: "part", part: target.part, answer };
       }
       case "job": {
-        const state = kernel.jobs.get(target.job)?.view.state ?? LOST;
-        return state.kind === "running" ? null : { kind: "job", job: target.job, end: state };
+        const end = await jobOutcome2(kernel, target.job);
+        return end === null ? null : { kind: "job", job: target.job, end };
       }
       case "timer":
         return null;
@@ -304,6 +306,20 @@ async function pendingCalls(kernel, sessions) {
   }));
   return found.flat();
 }
+async function readJob2(store, id) {
+  return load2(store, await store.refs.get(jobRef2(id)), decodeJobRecord2);
+}
+async function jobOutcome2(kernel, id) {
+  const local = kernel.jobs.get(id)?.view.state;
+  if (local !== undefined)
+    return local.kind === "running" ? null : local;
+  const found = await readJob2(kernel.store, id);
+  if (found === null)
+    return LOST;
+  if (found.record.end !== null)
+    return found.record.end;
+  return found.record.instance === kernel.instance || kernel.presence === null ? LOST : null;
+}
 function wake(kernel, session, record) {
   if (record.head === null && lapsed2(kernel, record))
     kernel.waits.rerun(session, record.id);
@@ -428,4 +444,4 @@ function lapsed2(kernel, record) {
   return record.result === null && record.waiting === null && record.reran !== null && record.reran.waits === record.waits.length && record.reran.holder !== kernel.instance && record.reran.expiresAt <= Date.now();
 }
 
-export { createWaitRegistry2, listSessionWaits2, loadWaits2, earliestWake2, waitFor2, runWait2, readParkedWait2, waitingOn2, lapsed2 };
+export { createWaitRegistry2, listSessionWaits2, loadWaits2, readJob2, jobOutcome2, earliestWake2, waitFor2, runWait2, readParkedWait2, waitingOn2, lapsed2 };

package/dist/chunks/compose-c4238qkb.js

@@ -0,0 +1,105 @@
+import {
+  IMAGE_LIMITS2
+} from "./compose-5z835ej2.js";
+import {
+  dev2
+} from "./compose-n116fnmp.js";
+
+// src/agent/images.ts
+var INLINE_IMAGE_TYPES = new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+]);
+async function modelImage2(images, file) {
+  const mime = normalizeImageType(file.mime);
+  const label = `Image ${file.name}, ${mime}`;
+  if (images === null)
+    return passThrough(file.bytes, mime, label, "no image processor is configured");
+  let prepared;
+  try {
+    prepared = await images.prepare(file.bytes, mime, IMAGE_LIMITS2);
+  } catch (cause) {
+    dev2("images", "prepare failed", { name: file.name, mime, cause: String(cause) });
+    return passThrough(file.bytes, mime, label, "the image processor failed");
+  }
+  if (prepared === undefined)
+    return [{ type: "text", text: `[${label}: left out, it cannot be prepared for the model]` }];
+  const image = { type: "image", data: prepared.data, mimeType: prepared.mimeType };
+  if (prepared.resized === undefined)
+    return [image];
+  const { from, to } = prepared.resized;
+  return [
+    image,
+    {
+      type: "text",
+      text: `[${label}: resized from ${from.width}x${from.height} to ${to.width}x${to.height}. Multiply coordinates by ${(from.width / to.width).toFixed(2)} to map them to the original.]`
+    }
+  ];
+}
+function passThrough(bytes, mime, label, unprepared) {
+  const omitted = (reason) => [
+    { type: "text", text: `[${label}: left out, ${reason} and ${unprepared}]` }
+  ];
+  if (!INLINE_IMAGE_TYPES.has(mime))
+    return omitted("the model does not take this format");
+  if (Math.ceil(bytes.byteLength / 3) * 4 > IMAGE_LIMITS2.maxBase64Bytes)
+    return omitted(`${String(bytes.byteLength)} bytes is too large to send`);
+  const size = imageDimensions(bytes, mime);
+  if (size === undefined)
+    return omitted("its size cannot be read");
+  if (size.width > IMAGE_LIMITS2.maxWidth || size.height > IMAGE_LIMITS2.maxHeight)
+    return omitted(`${String(size.width)}x${String(size.height)} is larger than ${String(IMAGE_LIMITS2.maxWidth)}x${String(IMAGE_LIMITS2.maxHeight)}`);
+  return [{ type: "image", data: bytes.toBase64(), mimeType: mime }];
+}
+function normalizeImageType(mime) {
+  const base = mime.split(";")[0]?.trim().toLowerCase() ?? "";
+  return base === "image/jpg" ? "image/jpeg" : base;
+}
+function imageDimensions(bytes, mime) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  switch (mime) {
+    case "image/png":
+      return bytes.length < 24 ? undefined : { width: view.getUint32(16), height: view.getUint32(20) };
+    case "image/gif":
+      return bytes.length < 10 ? undefined : { width: view.getUint16(6, true), height: view.getUint16(8, true) };
+    case "image/webp": {
+      if (bytes.length < 30)
+        return;
+      const chunk = new TextDecoder().decode(bytes.subarray(12, 16));
+      if (chunk === "VP8 ")
+        return {
+          width: view.getUint16(26, true) & 16383,
+          height: view.getUint16(28, true) & 16383
+        };
+      if (chunk === "VP8L") {
+        const bits = view.getUint32(21, true);
+        return { width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+      }
+      if (chunk === "VP8X") {
+        const uint24 = (offset) => view.getUint16(offset, true) + view.getUint8(offset + 2) * 65536;
+        return { width: uint24(24) + 1, height: uint24(27) + 1 };
+      }
+      return;
+    }
+    case "image/jpeg":
+      for (let offset = 2;offset + 9 <= bytes.length; ) {
+        if (bytes[offset] !== 255)
+          return;
+        const marker = view.getUint8(offset + 1);
+        if (marker === 255) {
+          offset++;
+          continue;
+        }
+        if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204)
+          return { width: view.getUint16(offset + 7), height: view.getUint16(offset + 5) };
+        offset += 2 + view.getUint16(offset + 2);
+      }
+      return;
+    default:
+      return;
+  }
+}
+
+export { modelImage2 };

package/dist/chunks/{compose-q1b0tppc.js → compose-c9wxgbjp.js}

@@ -1,17 +1,17 @@
 import {
   CORE_CONTEXT2
-} from "./compose-mryw0674.js";
+} from "./compose-5z835ej2.js";
 import {
   kvRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   requireSession2,
   put2,
   readKv2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-bbhk8vnr.js";
 
 // src/extend/plugin-api.ts
 import { isJsonObject, SdkError } from "@nyte-ai/schema";

package/dist/chunks/{compose-h272znxk.js → compose-cdj05t7x.js}

@@ -1,31 +1,31 @@
 import {
   envelope2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   partRef2,
   workspaceRef2,
   trustRef2,
   leaseRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   publishSet2
-} from "./compose-7b8ajk7a.js";
+} from "./compose-ad80nkkn.js";
 import {
   newRun2,
   begin2
-} from "./compose-vmhv4e00.js";
+} from "./compose-qxfq6dn9.js";
 import {
   createHostState2
 } from "./compose-xm52jghq.js";
 import {
   createHost2
-} from "./compose-7pc3p5ex.js";
+} from "./compose-zjj072km.js";
 import {
   createKernel2
-} from "./compose-1z7q169s.js";
+} from "./compose-q2zxbg41.js";
 import {
   memoryStore2
-} from "./compose-dckpgtks.js";
+} from "./compose-ts08bth2.js";
 
 // src/harness.ts
 import { asId } from "@nyte-ai/schema";

package/dist/chunks/{compose-kb22bkpt.js → compose-cqpjcx2t.js}

@@ -33,6 +33,9 @@ function endedRunRef2(id, run) {
 function liveRef2(id, run) {
   return `sessions/${id}/live/${run}`;
 }
+function runCallsPrefix2(id, run) {
+  return `sessions/${id}/calls/${run}:`;
+}
 function partRef2(id, part) {
   return `sessions/${id}/parts/${part}`;
 }
@@ -57,6 +60,14 @@ function kvRef2(scope, owner, key) {
 function leaseRef2(id, head) {
   return `sessions/${id}/leases/${head}`;
 }
+var PROCESSES2 = "processes/";
+function processRef2(instance) {
+  return `${PROCESSES2}${instance}`;
+}
+var JOBS2 = "jobs/";
+function jobRef2(id) {
+  return `${JOBS2}${id}`;
+}
 function hostIdentityRef2() {
   return "host/identity";
 }
@@ -64,4 +75,4 @@ function hostPrincipalsRef2() {
   return "host/principals";
 }
 
-export { sessionRef2, parseSessionRef2, parseHeadRef2, headRef2, inboxRef2, seenRef2, runRef2, endedRunRef2, liveRef2, partRef2, receiptRef2, callRef2, workspaceRef2, trustRef2, trustTarget2, kvRef2, leaseRef2, hostIdentityRef2, hostPrincipalsRef2 };
+export { sessionRef2, parseSessionRef2, parseHeadRef2, headRef2, inboxRef2, seenRef2, runRef2, endedRunRef2, liveRef2, runCallsPrefix2, partRef2, receiptRef2, callRef2, workspaceRef2, trustRef2, trustTarget2, kvRef2, leaseRef2, PROCESSES2, processRef2, JOBS2, jobRef2, hostIdentityRef2, hostPrincipalsRef2 };

package/dist/chunks/{compose-dbx6ftbm.js → compose-csh5vv2t.js}

@@ -1,15 +1,53 @@
 import {
   decodeKvValue2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   kvRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 
 // src/store/model-state.ts
-import { ModelRefType } from "@nyte-ai/schema";
+import { ModelRefType, ThinkingType } from "@nyte-ai/schema";
+import { Type } from "typebox";
 import { Value } from "typebox/value";
 var CHECK_INTERVAL_MS = 60000;
 var MODEL_PREFERENCE2 = kvRef2("host", "models", "default");
+var THINKING_PREFERENCES = kvRef2("host", "models", "thinking/");
+var MODEL_LISTINGS = kvRef2("host", "models", "listing/");
+var SavedListingType = Type.Enum(["hidden", "favorite"]);
+function modelListingRef2(model) {
+  return `${MODEL_LISTINGS}${model.provider}/${model.id}`;
+}
+async function readModelListings2(store) {
+  const refs = await store.refs.list(MODEL_LISTINGS);
+  const entries = await Promise.all(refs.map(async (ref) => {
+    if (ref.target === null)
+      return [];
+    const value = decodeKvValue2(await store.objects.get(ref.target));
+    return Value.Check(SavedListingType, value) ? [[ref.name.slice(MODEL_LISTINGS.length), value]] : [];
+  }));
+  return new Map(entries.flat());
+}
+function thinkingPreferenceRef2(model) {
+  return `${THINKING_PREFERENCES}${model.provider}/${model.id}`;
+}
+async function readThinkingPreference2(store, model) {
+  const ref = await store.refs.get(thinkingPreferenceRef2(model));
+  return ref === null || ref.target === null ? undefined : decodeThinking(await store.objects.get(ref.target));
+}
+async function readThinkingPreferences2(store) {
+  const refs = await store.refs.list(THINKING_PREFERENCES);
+  const entries = await Promise.all(refs.map(async (ref) => {
+    if (ref.target === null)
+      return [];
+    const level = decodeThinking(await store.objects.get(ref.target));
+    return level === undefined ? [] : [[ref.name.slice(THINKING_PREFERENCES.length), level]];
+  }));
+  return new Map(entries.flat());
+}
+function decodeThinking(object) {
+  const value = decodeKvValue2(object);
+  return Value.Check(ThinkingType, value) ? value : undefined;
+}
 async function readModelSelection2(store) {
   const ref = await store.refs.get(MODEL_PREFERENCE2);
   const value = ref === null || ref.target === null ? undefined : decodeKvValue2(await store.objects.get(ref.target));
@@ -147,4 +185,4 @@ function createModelState2(changed) {
   };
 }
 
-export { MODEL_PREFERENCE2, readModelSelection2, createModelState2 };
+export { MODEL_PREFERENCE2, modelListingRef2, readModelListings2, thinkingPreferenceRef2, readThinkingPreference2, readThinkingPreferences2, readModelSelection2, createModelState2 };