railcode 0.1.26 → 0.1.27

package/static/sdk.js

@@ -4,6 +4,7 @@
   // ../sdk/src/inspector.ts
   var entries = [];
   var isOpen = localStorage.getItem("__sdk_open") === "1";
+  var selected = null;
   var host = document.createElement("div");
   host.id = "__sdk_inspector";
   var root = host.attachShadow({ mode: "open" });
@@ -25,26 +26,42 @@
       font-size:12px; padding:4px 9px; cursor:pointer; }
     header button:hover { background:#232a33; color:#fff; }
     .log { flex:1; overflow:auto; padding:6px 0; }
-    .row { display:grid; grid-template-columns: 12px auto 1fr; gap:8px; align-items:baseline;
-      padding:7px 14px; border-bottom:1px solid #1d2127; }
+    .row { display:grid; grid-template-columns: 12px 1fr; gap:8px; align-items:start;
+      padding:7px 14px; border-bottom:1px solid #1d2127; cursor:pointer; }
+    .row:hover { background:#181c22; }
     .row .dot { width:8px; height:8px; border-radius:50%; margin-top:5px; }
     .row.pending .dot { background:#f59e0b; animation:pulse 1s infinite; }
     .row.ok .dot { background:#34d399; } .row.error .dot { background:#f87171; }
     @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.3} }
-    .kind { font-size:9.5px; font-weight:700; letter-spacing:.05em; text-transform:uppercase;
-      padding:2px 6px; border-radius:4px; white-space:nowrap; align-self:start; margin-top:2px; }
+    .kind { display:inline-block; font-size:9.5px; font-weight:700; letter-spacing:.05em; text-transform:uppercase;
+      padding:2px 6px; border-radius:4px; white-space:nowrap; margin-bottom:4px; }
     .k-sql { background:#1e3a5f; color:#7cc4ff; } .k-db { background:#3a2752; color:#c79bff; }
     .k-files { background:#13413c; color:#5fd6c4; } .k-llm { background:#4a2b16; color:#f6b26b; }
     .k-me, .k-connections, .k-app-users, .k-roles { background:#2a2f38; color:#9aa4b2; }
     .body { min-width:0; }
     code { font-family: ui-monospace, "SF Mono", Menlo, monospace; font-size:11.5px; color:#e6e8eb;
       word-break:break-word; display:block; line-height:1.45; }
-    .res { color:#7b8493; font-size:11px; margin-top:2px; }
+    .res { color:#7b8493; font-size:11px; margin-top:2px; display:block; }
     .res.error { color:#f87171; }
     .res i { font-style:normal; color:#5b6472; }
     .empty { color:#5b6472; text-align:center; padding:30px 16px; font-size:12px; }
     footer { padding:9px 14px; border-top:1px solid #262b33; color:#5b6472; font-size:10.5px; }
     footer code { display:inline; color:#7b8493; font-size:10.5px; }
+    .backdrop { position:fixed; inset:0; background:rgba(0,0,0,.5); z-index:2147483002;
+      display:none; align-items:center; justify-content:center; padding:24px; }
+    .backdrop.open { display:flex; }
+    .detail { background:#14171c; border:1px solid #262b33; border-radius:10px; width:560px;
+      max-width:100%; max-height:85vh; display:flex; flex-direction:column;
+      box-shadow:0 20px 60px rgba(0,0,0,.5); }
+    .detail .content { padding:14px; overflow:auto; }
+    .meta { display:flex; align-items:center; gap:10px; margin-bottom:12px; color:#7b8493; font-size:11.5px; }
+    .section { margin-bottom:14px; } .section:last-child { margin-bottom:0; }
+    .section .label { font-size:10px; text-transform:uppercase; letter-spacing:.05em; color:#5b6472;
+      margin-bottom:6px; font-weight:700; }
+    .detail pre { margin:0; white-space:pre-wrap; word-break:break-word; font-family: ui-monospace,
+      "SF Mono", Menlo, monospace; font-size:11.5px; line-height:1.5; color:#e6e8eb; background:#0e1013;
+      border:1px solid #1d2127; border-radius:6px; padding:10px 12px; max-height:320px; overflow:auto; }
+    .detail pre.error-text { color:#f87171; }
   </style>
   <div class="panel" id="panel">
     <header>
@@ -55,22 +72,52 @@
     </header>
     <div class="log" id="log"></div>
     <footer>Calls made via <code>postgres()</code>, <code>llm</code>, <code>db</code>, <code>files</code>, <code>me()</code>, <code>appUsers()</code>, <code>roles()</code></footer>
+  </div>
+  <div class="backdrop" id="backdrop">
+    <div class="detail">
+      <header>
+        <div class="t">Call detail</div>
+        <div class="grow"></div>
+        <button id="detail-close">Close</button>
+      </header>
+      <div class="content" id="detail-content"></div>
+    </div>
   </div>`;
   function mount() {
     (document.body || document.documentElement).appendChild(host);
     root.getElementById("collapse").onclick = () => setOpen(false);
     root.getElementById("clear").onclick = () => {
       entries.length = 0;
+      selected = null;
       render();
     };
+    root.getElementById("log").addEventListener("click", (ev) => {
+      const rowEl = ev.target.closest(".row");
+      if (!rowEl) return;
+      const idx = Number(rowEl.dataset.idx);
+      const entry = entries[idx];
+      if (!entry) return;
+      selected = entry;
+      renderDetail();
+    });
+    root.getElementById("detail-close").onclick = () => closeDetail();
+    root.getElementById("backdrop").addEventListener("click", (ev) => {
+      if (ev.target === root.getElementById("backdrop")) closeDetail();
+    });
     applyWidth();
   }
   if (document.body) mount();
   else document.addEventListener("DOMContentLoaded", mount);
+  function closeDetail() {
+    selected = null;
+    renderDetail();
+  }
   window.addEventListener("keydown", (e) => {
     if (e.ctrlKey && !e.metaKey && !e.altKey && e.code === "Backquote") {
       e.preventDefault();
       setOpen(!isOpen);
+    } else if (e.code === "Escape" && selected) {
+      closeDetail();
     }
   });
   function applyWidth() {
@@ -88,18 +135,69 @@
   var escHtml = (s) => String(s == null ? "" : s).replace(/[&<>]/g, (c) => escMap[c]);
   function render() {
     const log = root.getElementById("log");
-    if (!log) return;
-    if (!entries.length) {
-      log.innerHTML = '<div class="empty">No calls yet. Interact with the app to see SDK activity.</div>';
+    if (log) {
+      if (!entries.length) {
+        log.innerHTML = '<div class="empty">No calls yet. Interact with the app to see SDK activity.</div>';
+      } else {
+        log.innerHTML = entries.map((e, i) => {
+          const res = e.status === "pending" ? '<span class="res">running\u2026</span>' : e.status === "error" ? `<span class="res error">\u2715 ${escHtml(e.error)} <i>${e.ms}ms</i></span>` : `<span class="res">${escHtml(e.result)} <i>${e.ms}ms</i></span>`;
+          return `<div class="row ${e.status}" data-idx="${i}"><span class="dot"></span>
+            <div class="body">
+              <span class="kind k-${e.kind}">${e.kind}</span>
+              <code>${escHtml(e.label)}</code>${res}
+            </div></div>`;
+        }).join("");
+        log.scrollTop = log.scrollHeight;
+      }
+    }
+    renderDetail();
+  }
+  function prettyPrint(value) {
+    if (value === void 0) return "";
+    if (typeof value === "string") {
+      try {
+        return JSON.stringify(JSON.parse(value), null, 2);
+      } catch {
+        return value;
+      }
+    }
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+  function renderDetail() {
+    const backdrop = root.getElementById("backdrop");
+    const box = root.getElementById("detail-content");
+    if (!backdrop || !box) return;
+    if (!selected) {
+      backdrop.classList.remove("open");
+      box.innerHTML = "";
       return;
     }
-    log.innerHTML = entries.map((e) => {
-      const res = e.status === "pending" ? '<span class="res">running\u2026</span>' : e.status === "error" ? `<span class="res error">\u2715 ${escHtml(e.error)} <i>${e.ms}ms</i></span>` : `<span class="res">${escHtml(e.result)} <i>${e.ms}ms</i></span>`;
-      return `<div class="row ${e.status}"><span class="dot"></span>
-        <span class="kind k-${e.kind}">${e.kind}</span>
-        <span class="body"><code>${escHtml(e.label)}</code>${res}</span></div>`;
-    }).join("");
-    log.scrollTop = log.scrollHeight;
+    const e = selected;
+    const statusLabel = e.status === "pending" ? "pending\u2026" : e.status === "error" ? `failed \xB7 ${e.ms}ms` : `ok \xB7 ${e.ms}ms`;
+    const sections = [
+      `<div class="section"><div class="label">Call</div><pre>${escHtml(e.full ?? e.label)}</pre></div>`
+    ];
+    if (e.status === "error") {
+      sections.push(
+        `<div class="section"><div class="label">Error</div><pre class="error-text">${escHtml(prettyPrint(e.error))}</pre></div>`
+      );
+      if (e.errorStack) {
+        sections.push(
+          `<div class="section"><div class="label">Stack</div><pre class="error-text">${escHtml(e.errorStack)}</pre></div>`
+        );
+      }
+    } else if (e.status === "ok") {
+      const result = e.resultFull !== void 0 ? prettyPrint(e.resultFull) : e.result ?? "";
+      sections.push(`<div class="section"><div class="label">Result</div><pre>${escHtml(result)}</pre></div>`);
+    }
+    box.innerHTML = `
+    <div class="meta"><span class="kind k-${e.kind}">${e.kind}</span><span>${statusLabel}</span></div>
+    ${sections.join("")}`;
+    backdrop.classList.add("open");
   }
   var Inspector = {
     add(entry) {
@@ -178,14 +276,15 @@
     }
     return shorten(String(res), 48);
   }
-  function track(kind, label3, thunk) {
-    const entry = { kind, label: label3, status: "pending", t0: performance.now() };
+  function track(kind, label3, thunk, full) {
+    const entry = { kind, label: label3, full, status: "pending", t0: performance.now() };
     Inspector.add(entry);
     return thunk().then(
       (res) => {
         entry.status = "ok";
         entry.ms = Math.round(performance.now() - entry.t0);
         entry.result = summarize(res);
+        entry.resultFull = res;
         Inspector.update();
         return res;
       },
@@ -193,29 +292,36 @@
         entry.status = "error";
         entry.ms = Math.round(performance.now() - entry.t0);
         entry.error = err.message;
+        entry.errorStack = err.stack;
         Inspector.update();
         throw err;
       }
     );
   }
-  function trackStream(kind, label3, streamFactory) {
-    const entry = { kind, label: label3, status: "pending", t0: performance.now() };
+  function trackStream(kind, label3, streamFactory, full) {
+    const entry = { kind, label: label3, full, status: "pending", t0: performance.now() };
     Inspector.add(entry);
     return async function* () {
       let textLen = 0;
+      let streamed = "";
       try {
         for await (const event of streamFactory()) {
-          if (event && event.type === "text") textLen += event.text.length;
+          if (event && event.type === "text") {
+            textLen += event.text.length;
+            streamed += event.text;
+          }
           yield event;
         }
         entry.status = "ok";
         entry.ms = Math.round(performance.now() - entry.t0);
         entry.result = textLen ? `${textLen} chars streamed` : "done";
+        entry.resultFull = streamed || void 0;
         Inspector.update();
       } catch (err) {
         entry.status = "error";
         entry.ms = Math.round(performance.now() - entry.t0);
         entry.error = err.message;
+        entry.errorStack = err.stack;
         Inspector.update();
         throw err;
       }
@@ -265,6 +371,191 @@
   }).catch(() => {
   });
 
+  // ../sdk/src/app-bar.ts
+  var BAR_H = 46;
+  function hostUrls(who) {
+    const host2 = location.host;
+    const proto = location.protocol;
+    const two = `${who.app.slug}.${who.org.slug}.`;
+    const one = `${who.app.slug}.`;
+    if (host2.startsWith(two)) {
+      const parent = host2.slice(two.length);
+      return { login: `${proto}//${parent}/login`, launcher: `${proto}//${who.org.slug}.${parent}/` };
+    }
+    if (host2.startsWith(one)) {
+      const parent = host2.slice(one.length);
+      return { login: `${proto}//${parent}/login`, launcher: `${proto}//${parent}/` };
+    }
+    return { login: "/login", launcher: "/" };
+  }
+  function initials(name, email2) {
+    const parts = name.trim().split(/\s+/).filter(Boolean);
+    if (parts.length >= 2) return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
+    if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
+    return (email2.trim()[0] || "?").toUpperCase();
+  }
+  function mount3(who) {
+    const urls2 = hostUrls(who);
+    const displayName = who.user.name?.trim() || who.user.email;
+    const host2 = document.createElement("div");
+    host2.id = "__rc_appbar";
+    const root2 = host2.attachShadow({ mode: "open" });
+    root2.innerHTML = `
+    <style>
+      :host { all: initial; }
+      * { box-sizing: border-box; font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; }
+
+      /* Railcode tokens \u2014 light. */
+      .rc {
+        --h: ${BAR_H}px; --radius: 8px;
+        --bg: #ffffff; --fg: #1a1f36; --muted: #687385; --accent: #f0f1f4;
+        --border: #e6e8eb; --primary: #2563eb; --ring: #2563eb;
+      }
+      @media (prefers-color-scheme: dark) {
+        .rc {
+          --bg: #1f1f23; --fg: #ededee; --muted: #9b9ba3; --accent: #27272b;
+          --border: #2c2c31; --primary: #60a5fa; --ring: #60a5fa;
+        }
+      }
+
+      .bar {
+        position: fixed; top: 0; left: 0; right: 0; z-index: 2147483000;
+        height: var(--h); display: grid; grid-template-columns: 1fr auto 1fr;
+        align-items: center; gap: 12px; padding: 0 12px;
+        background: var(--bg); color: var(--fg);
+        border-bottom: 1px solid var(--border);
+        transition: transform 180ms ease;
+        -webkit-font-smoothing: antialiased;
+      }
+      .rc.collapsed .bar { transform: translateY(-100%); }
+
+      /* Left: Railcode \u2192 launcher */
+      .brand {
+        justify-self: start; display: inline-flex; align-items: center;
+        padding: 4px 6px; border: 0; background: transparent; cursor: pointer;
+        color: inherit; border-radius: var(--radius); font-size: 14.5px;
+        font-weight: 600; letter-spacing: -0.01em; line-height: 1;
+        transition: background-color 120ms ease;
+      }
+      .brand:hover { background: color-mix(in srgb, var(--fg) 4%, transparent); }
+
+      /* Center: app name */
+      .app {
+        justify-self: center; min-width: 0; font-size: 13px; font-weight: 500;
+        letter-spacing: -0.005em; white-space: nowrap; overflow: hidden;
+        text-overflow: ellipsis; color: var(--fg);
+      }
+
+      /* Right: user + logout + collapse */
+      .right { justify-self: end; display: inline-flex; align-items: center; gap: 8px; min-width: 0; }
+      .user { display: inline-flex; align-items: center; gap: 8px; min-width: 0; }
+      .avatar {
+        width: 24px; height: 24px; border-radius: 999px; display: grid;
+        place-items: center; font-size: 10.5px; font-weight: 600; flex: none;
+        color: var(--primary); background: color-mix(in srgb, var(--primary) 14%, transparent);
+      }
+      .name {
+        font-size: 13px; font-weight: 500; white-space: nowrap; overflow: hidden;
+        text-overflow: ellipsis; max-width: 160px; color: var(--fg);
+      }
+      .sep { width: 1px; height: 18px; background: var(--border); flex: none; }
+
+      .logout {
+        display: inline-flex; align-items: center; gap: 6px; height: 28px;
+        padding: 0 10px; border: 1px solid transparent; border-radius: var(--radius);
+        background: transparent; color: var(--muted); font: inherit; font-size: 12.5px;
+        font-weight: 500; cursor: pointer; transition: background-color 120ms ease, color 120ms ease;
+      }
+      .logout:hover { background: var(--accent); color: var(--fg); }
+      .logout:focus-visible { outline: 2px solid color-mix(in srgb, var(--ring) 45%, transparent); outline-offset: 1px; }
+
+      .collapse {
+        display: grid; place-items: center; width: 28px; height: 28px;
+        border: 1px solid transparent; border-radius: var(--radius); background: transparent;
+        color: var(--muted); cursor: pointer; transition: background-color 120ms ease, color 120ms ease;
+      }
+      .collapse:hover { background: var(--accent); color: var(--fg); }
+      .collapse:focus-visible { outline: 2px solid color-mix(in srgb, var(--ring) 45%, transparent); outline-offset: 1px; }
+
+      /* Reopen caret \u2014 near-transparent while it sits over the app; solidifies on
+         hover. Click only (no hover-to-open). A light blur keeps it legible over
+         busy content without reading as a solid chip. */
+      .reveal {
+        position: fixed; top: 0; left: 50%; z-index: 2147482999;
+        transform: translateX(-50%) translateY(-100%);
+        display: inline-flex; align-items: center; justify-content: center;
+        height: 20px; padding: 0 16px 1px;
+        border: 1px solid color-mix(in srgb, var(--border) 45%, transparent); border-top: 0;
+        border-radius: 0 0 var(--radius) var(--radius);
+        background: color-mix(in srgb, var(--bg) 10%, transparent);
+        color: color-mix(in srgb, var(--muted) 60%, transparent);
+        -webkit-backdrop-filter: blur(6px); backdrop-filter: blur(6px);
+        cursor: pointer;
+        transition: transform 180ms ease, background-color 120ms ease, color 120ms ease, border-color 120ms ease;
+      }
+      .rc.collapsed .reveal { transform: translateX(-50%) translateY(0); }
+      .reveal:hover { background: var(--bg); border-color: var(--border); color: var(--fg); }
+
+      svg { display: block; }
+    </style>
+
+    <div class="rc collapsed">
+      <header class="bar">
+        <button class="brand" type="button" title="Back to apps">Railcode</button>
+        <span class="app"></span>
+        <div class="right">
+          <div class="user">
+            <span class="avatar"></span>
+            <span class="name"></span>
+          </div>
+          <span class="sep"></span>
+          <button class="logout" type="button">
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+              <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4"/>
+              <polyline points="16 17 21 12 16 7"/>
+              <line x1="21" y1="12" x2="9" y2="12"/>
+            </svg>
+            Log out
+          </button>
+          <button class="collapse" type="button" title="Collapse bar">
+            <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+              <polyline points="18 15 12 9 6 15"/>
+            </svg>
+          </button>
+        </div>
+      </header>
+
+      <button class="reveal" type="button" title="Show bar">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <polyline points="6 9 12 15 18 9"/>
+        </svg>
+      </button>
+    </div>`;
+    const rc = root2.querySelector(".rc");
+    root2.querySelector(".app").textContent = who.app.name || who.app.slug;
+    root2.querySelector(".name").textContent = displayName;
+    root2.querySelector(".avatar").textContent = initials(who.user.name || "", who.user.email);
+    const docEl = document.documentElement;
+    docEl.style.transition = "padding-top 180ms ease";
+    const setCollapsed = (collapsed) => {
+      rc.classList.toggle("collapsed", collapsed);
+      docEl.style.paddingTop = collapsed ? "" : `${BAR_H}px`;
+    };
+    root2.querySelector(".brand").onclick = () => location.assign(urls2.launcher);
+    root2.querySelector(".collapse").onclick = () => setCollapsed(true);
+    root2.querySelector(".reveal").onclick = () => setCollapsed(false);
+    root2.querySelector(".logout").onclick = async () => {
+      try {
+        await fetch("/_api/logout", { method: "POST", credentials: "include" });
+      } catch {
+      }
+      location.assign(urls2.login);
+    };
+    (document.body || document.documentElement).appendChild(host2);
+  }
+  me().then(mount3).catch(() => {
+  });
+
   // ../sdk/src/agents.ts
   var TERMINAL = ["success", "failed", "cancelled", "limit_exceeded"];
   var POLL_MIN_MS = 400;
@@ -314,25 +605,28 @@
     rows.truncated = r.truncated;
     return rows;
   };
-  var runSQL = (engine, connection, query2, params) => {
-    const trimmed = shorten(query2.replace(/\s+/g, " ").trim(), QUERY_LABEL_MAX);
-    const label3 = `${engine ?? "data"}(${q(connection)}).runSQL(${q(trimmed)}${params && params.length ? `, ${shorten(JSON.stringify(params), PARAMS_LABEL_MAX)}` : ""})`;
+  var runSQL = (engine2, connection, query2, params) => {
+    const trimmedQuery = query2.replace(/\s+/g, " ").trim();
+    const paramsJson = params && params.length ? JSON.stringify(params) : "";
+    const label3 = `${engine2 ?? "data"}(${q(connection)}).runSQL(${q(shorten(trimmedQuery, QUERY_LABEL_MAX))}${paramsJson ? `, ${shorten(paramsJson, PARAMS_LABEL_MAX)}` : ""})`;
+    const full = `${engine2 ?? "data"}(${q(connection)}).runSQL(${q(trimmedQuery)}${paramsJson ? `, ${paramsJson}` : ""})`;
     return track(
       "sql",
       label3,
       () => call("POST", "/sql", {
         // engine is advisory; omit it for the generic data() namespace so the backend
         // dispatches on the connection's stored kind. postgres() pins engine="postgres".
-        body: { ...engine ? { engine } : {}, connection, query: query2, params: params || [] }
-      }).then(toSqlRows)
+        body: { ...engine2 ? { engine: engine2 } : {}, connection, query: query2, params: params || [] }
+      }).then(toSqlRows),
+      full
     );
   };
-  var namespace = (engine) => {
+  var namespace = (engine2) => {
     const handle = (connection) => ({
-      runSQL: (query2, params) => runSQL(engine, connection, query2, params)
+      runSQL: (query2, params) => runSQL(engine2, connection, query2, params)
     });
     const ns = handle;
-    ns.runSQL = (query2, params) => runSQL(engine, "default", query2, params);
+    ns.runSQL = (query2, params) => runSQL(engine2, "default", query2, params);
     return ns;
   };
   var data = namespace();
@@ -442,13 +736,19 @@
     }
     /** Upsert ``key`` → ``value``; returns the stored value. */
     put(key, value) {
-      return track("db", this.label(`put(${q(key)}, ${shorten(JSON.stringify(value), 40)})`), async () => {
-        const record = await call("PUT", `/kv/${encPath(this.name)}/${encPath(key)}`, {
-          body: { value },
-          query: scopeParams(this.scope)
-        });
-        return record.value;
-      });
+      const valueJson = JSON.stringify(value);
+      return track(
+        "db",
+        this.label(`put(${q(key)}, ${shorten(valueJson, 40)})`),
+        async () => {
+          const record = await call("PUT", `/kv/${encPath(this.name)}/${encPath(key)}`, {
+            body: { value },
+            query: scopeParams(this.scope)
+          });
+          return record.value;
+        },
+        this.label(`put(${q(key)}, ${valueJson})`)
+      );
     }
     delete(key) {
       return track(
@@ -579,12 +879,12 @@
   async function urls(scope, names) {
     return track("files", `${scopeLabel2(scope)}.urls(<${names.length} names>)`, async () => {
       const unique = [...new Set(names)];
-      const now = Date.now();
+      const now2 = Date.now();
       const items = /* @__PURE__ */ new Map();
       const unresolved = [];
       for (const name of unique) {
         const cached = urlCache.get(cacheKey(scope, name));
-        if (cached && cached.expiresAt > now + URL_EXPIRY_MARGIN_MS) items.set(name, cached.item);
+        if (cached && cached.expiresAt > now2 + URL_EXPIRY_MARGIN_MS) items.set(name, cached.item);
         else {
           urlCache.delete(cacheKey(scope, name));
           unresolved.push(name);
@@ -599,7 +899,7 @@
         missing = resolved.missing;
         for (const item of resolved.items) {
           const normalized = { ...item, url: new URL(item.url, location.origin).toString() };
-          const expiresAt = item.expires_in === null ? Number.POSITIVE_INFINITY : now + item.expires_in * 1e3;
+          const expiresAt = item.expires_in === null ? Number.POSITIVE_INFINITY : now2 + item.expires_in * 1e3;
           urlCache.set(cacheKey(scope, item.name), { item: normalized, expiresAt });
           items.set(item.name, normalized);
         }
@@ -640,11 +940,383 @@
     delete: shared2.delete
   };
 
+  // ../sdk/src/tool-loop.ts
+  var OBSERVATION_CHARS = 6e3;
+  var DEFAULT_LIMITS = {
+    maxSteps: 8,
+    maxToolCalls: 30,
+    timeoutMs: 12e4
+  };
+  var LlmRunError = class extends Error {
+    constructor(message, step, cause) {
+      super(message);
+      this.name = "LlmRunError";
+      this.step = step;
+      this.cause = cause;
+    }
+  };
+  var now = () => typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  var toMessages = (input) => typeof input === "string" ? [{ role: "user", content: input }] : input.map((m) => ({ ...m }));
+  var errMessage = (err) => err instanceof Error ? err.message : typeof err === "string" ? err : JSON.stringify(err);
+  function clip(text, n) {
+    return text.length > n ? `${text.slice(0, n)}\u2026 (${text.length - n} more chars)` : text;
+  }
+  function defaultStringify(value) {
+    if (value === void 0) return "undefined";
+    try {
+      const s = JSON.stringify(value);
+      return s === void 0 ? String(value) : s;
+    } catch {
+      return String(value);
+    }
+  }
+  function summarizeResult(tool, raw) {
+    if (tool.summarize) {
+      try {
+        return clip(String(tool.summarize(raw)), OBSERVATION_CHARS);
+      } catch {
+      }
+    }
+    return clip(defaultStringify(raw), OBSERVATION_CHARS);
+  }
+  var JS_TYPE_OK = {
+    string: (v) => typeof v === "string",
+    number: (v) => typeof v === "number" && !Number.isNaN(v),
+    integer: (v) => typeof v === "number" && Number.isInteger(v),
+    boolean: (v) => typeof v === "boolean",
+    object: (v) => typeof v === "object" && v !== null && !Array.isArray(v),
+    array: (v) => Array.isArray(v),
+    null: (v) => v === null
+  };
+  function typeMatches(type, value) {
+    const allowed = Array.isArray(type) ? type : [type];
+    return allowed.some((t) => typeof t === "string" && JS_TYPE_OK[t]?.(value));
+  }
+  function validateArgs(schema, args) {
+    if (!schema || typeof schema !== "object") return null;
+    if (schema.type && schema.type !== "object") {
+      return typeMatches(schema.type, args) ? null : `arguments must be of type ${schema.type}`;
+    }
+    if (typeof args !== "object" || args === null || Array.isArray(args)) {
+      return "arguments must be an object";
+    }
+    const obj = args;
+    for (const key of schema.required ?? []) {
+      if (!(key in obj)) return `missing required property "${key}"`;
+    }
+    const props = schema.properties ?? {};
+    for (const [key, spec] of Object.entries(props)) {
+      if (!(key in obj) || spec == null) continue;
+      const value = obj[key];
+      if (spec.type && !typeMatches(spec.type, value)) {
+        return `property "${key}" must be of type ${JSON.stringify(spec.type)}`;
+      }
+      if (Array.isArray(spec.enum) && !spec.enum.includes(value)) {
+        return `property "${key}" must be one of ${JSON.stringify(spec.enum)}`;
+      }
+    }
+    return null;
+  }
+  function assistantTurn(text, calls) {
+    const decided = calls.map((c) => `${c.name}(${defaultStringify(c.arguments)})`).join(", ");
+    const content = text ? `${text}
+
+[calling tools: ${decided}]` : `[calling tools: ${decided}]`;
+    return { role: "assistant", content };
+  }
+  function observationTurn(lines) {
+    return { role: "user", content: `Tool results:
+${lines.join("\n")}` };
+  }
+  var RunLedger = class {
+    constructor() {
+      this.usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+      this.model = "";
+      this.provider = "";
+      this.finishReason = null;
+      this.requestId = "";
+      this.costSum = 0;
+      this.costSeen = false;
+      this.costMissing = false;
+    }
+    turn(t) {
+      this.usage.inputTokens += t.usage.inputTokens;
+      this.usage.outputTokens += t.usage.outputTokens;
+      this.usage.totalTokens += t.usage.totalTokens;
+      if (t.model) this.model = t.model;
+      if (t.provider) this.provider = t.provider;
+      if (t.finishReason !== void 0) this.finishReason = t.finishReason;
+      if (t.requestId) this.requestId = t.requestId;
+      const parsed = t.cost == null ? NaN : Number(t.cost);
+      if (Number.isFinite(parsed)) {
+        this.costSum += parsed;
+        this.costSeen = true;
+      } else {
+        this.costMissing = true;
+      }
+    }
+    /** Sum of per-turn costs; null unless every turn reported one. */
+    get cost() {
+      if (!this.costSeen || this.costMissing) return null;
+      return this.costSum.toFixed(10).replace(/0+$/, "").replace(/\.$/, "");
+    }
+  };
+  var toDefs = (tools2) => tools2.map((t) => ({ name: t.name, description: t.description, schema: t.schema }));
+  async function* engine(input, opts, wire2, streamFinal) {
+    const tools2 = opts.tools ?? [];
+    const toolsByName = new Map(tools2.map((t) => [t.name, t]));
+    const toolDefs = toDefs(tools2);
+    const limits = { ...DEFAULT_LIMITS, ...opts.limits };
+    const { system: baseSystem, model, provider, output, maxOutputTokens, metadata } = opts;
+    const messages = toMessages(input);
+    const steps = [];
+    const ledger = new RunLedger();
+    if (model) ledger.model = model;
+    let toolExecs = 0;
+    let turn = 0;
+    let finalText = "";
+    let finalOutput = null;
+    let hasStructuredOutput = false;
+    let stopReason = "end";
+    const controller = new AbortController();
+    let abortReason = "aborted";
+    const onExternalAbort = () => {
+      abortReason = "aborted";
+      controller.abort();
+    };
+    if (opts.signal) {
+      if (opts.signal.aborted) controller.abort();
+      else opts.signal.addEventListener("abort", onExternalAbort, { once: true });
+    }
+    const timer = setTimeout(() => {
+      abortReason = "timeout";
+      controller.abort();
+    }, limits.timeoutMs);
+    const signal = controller.signal;
+    const budgetSystem = () => {
+      if (!limits.maxSteps) return baseSystem;
+      const line = `You have used ${turn} of ${limits.maxSteps} tool steps.`;
+      return baseSystem ? `${baseSystem}
+
+${line}` : line;
+    };
+    async function* planTurn(system) {
+      const turnOpts = {
+        system,
+        tools: toolDefs,
+        model,
+        provider,
+        maxOutputTokens,
+        metadata,
+        signal
+      };
+      if (!streamFinal) {
+        try {
+          const result = await wire2.generate(messages, turnOpts);
+          ledger.turn(result);
+          return { text: result.text, toolCalls: result.toolCalls ?? [] };
+        } catch (err) {
+          if (signal.aborted) return { text: "", toolCalls: [] };
+          throw err;
+        }
+      }
+      let turnText = "";
+      let toolCalls = [];
+      try {
+        for await (const event of wire2.stream(messages, turnOpts)) {
+          if (signal.aborted) break;
+          if (event.type === "text") {
+            turnText += event.text;
+            yield { type: "text", text: event.text };
+          } else if (event.type === "done") {
+            ledger.turn(event);
+            toolCalls = event.toolCalls ?? [];
+          } else if (event.type === "error") {
+            throw new LlmRunError(event.message, turn, event);
+          }
+        }
+      } catch (err) {
+        if (!signal.aborted) throw err;
+      }
+      return { text: turnText, toolCalls };
+    }
+    try {
+      planning: while (true) {
+        if (signal.aborted) {
+          stopReason = abortReason;
+          break;
+        }
+        if (turn >= limits.maxSteps) {
+          stopReason = "max_steps";
+          break;
+        }
+        const system = budgetSystem();
+        turn += 1;
+        const result = yield* planTurn(system);
+        if (signal.aborted) {
+          finalText = result.text;
+          stopReason = abortReason;
+          break;
+        }
+        if (result.toolCalls.length === 0) {
+          finalText = result.text;
+          stopReason = "end";
+          break;
+        }
+        messages.push(assistantTurn(result.text, result.toolCalls));
+        const observations = [];
+        for (const call2 of result.toolCalls) {
+          if (signal.aborted) {
+            messages.push(observationTurn(observations.length ? observations : ["(cancelled)"]));
+            stopReason = abortReason;
+            break planning;
+          }
+          if (toolExecs >= limits.maxToolCalls) {
+            observations.push(`- ${call2.name}: skipped (tool-call budget exhausted)`);
+            stopReason = "max_tool_calls";
+            continue;
+          }
+          toolExecs += 1;
+          const step = {
+            id: call2.id || `step_${toolExecs}`,
+            index: toolExecs,
+            tool: call2.name,
+            args: call2.arguments,
+            status: "running",
+            result: null,
+            error: null,
+            ms: null
+          };
+          steps.push(step);
+          yield { type: "step", step: { ...step } };
+          const started = now();
+          let observation;
+          const tool = toolsByName.get(call2.name);
+          if (!tool) {
+            step.status = "error";
+            step.error = `Unknown tool "${call2.name}"`;
+            observation = step.error;
+          } else {
+            const invalid = validateArgs(tool.schema, call2.arguments);
+            if (invalid) {
+              step.status = "error";
+              step.error = invalid;
+              observation = `Invalid arguments: ${invalid}`;
+            } else {
+              try {
+                const raw = await tool.run(call2.arguments, { signal, step: turn });
+                step.status = "ok";
+                step.result = raw;
+                observation = summarizeResult(tool, raw);
+              } catch (err) {
+                step.status = "error";
+                step.error = errMessage(err);
+                observation = `Error: ${step.error}`;
+              }
+            }
+          }
+          step.ms = Math.round(now() - started);
+          observations.push(`- ${call2.name} [${step.id}]: ${observation}`);
+          yield { type: "step", step: { ...step } };
+        }
+        messages.push(observationTurn(observations));
+        if (stopReason === "max_tool_calls") break;
+      }
+      if (output && output.type === "json" && stopReason === "end" && !hasStructuredOutput) {
+        const result = await wire2.generate(messages, {
+          system: baseSystem,
+          output,
+          model,
+          provider,
+          maxOutputTokens,
+          metadata,
+          signal
+        });
+        ledger.turn(result);
+        finalText = result.text;
+        finalOutput = result.output;
+        hasStructuredOutput = true;
+        if (streamFinal && finalText) yield { type: "text", text: finalText };
+      }
+      if (finalText) messages.push({ role: "assistant", content: finalText });
+      yield {
+        type: "done",
+        usage: ledger.usage,
+        cost: ledger.cost,
+        provider: ledger.provider,
+        model: ledger.model,
+        finishReason: ledger.finishReason,
+        requestId: ledger.requestId,
+        text: finalText,
+        output: hasStructuredOutput ? finalOutput : null,
+        steps,
+        messages,
+        stopReason
+      };
+    } catch (err) {
+      const cause = err instanceof LlmRunError ? err.cause : err;
+      const wireError = cause && typeof cause === "object" && "error" in cause ? cause : void 0;
+      yield {
+        type: "error",
+        error: typeof wireError?.error === "string" ? wireError.error : "tool_loop_error",
+        message: errMessage(err),
+        ...wireError?.retryable !== void 0 ? { retryable: wireError.retryable } : {},
+        ...wireError?.requestId !== void 0 ? { requestId: wireError.requestId } : {},
+        step: err instanceof LlmRunError ? err.step : turn
+      };
+    } finally {
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onExternalAbort);
+    }
+  }
+  function streamToolLoop(input, opts, wire2) {
+    return engine(input, opts, wire2, true);
+  }
+  async function runToolLoop(input, opts, wire2) {
+    for await (const event of engine(input, opts, wire2, false)) {
+      if (event.type === "done") {
+        return {
+          text: event.text ?? "",
+          output: event.output ?? null,
+          toolCalls: [],
+          usage: event.usage,
+          cost: event.cost,
+          provider: event.provider,
+          model: event.model,
+          finishReason: event.finishReason,
+          requestId: event.requestId,
+          steps: event.steps,
+          messages: event.messages,
+          stopReason: event.stopReason
+        };
+      }
+      if (event.type === "error") {
+        throw new LlmRunError(event.message, event.step ?? null, event);
+      }
+    }
+    throw new LlmRunError("tool loop produced no result", null, null);
+  }
+
   // ../sdk/src/llm.ts
+  function toolMode(tools2) {
+    if (!tools2 || tools2.length === 0) return "none";
+    const withRun = tools2.filter((t) => typeof t.run === "function").length;
+    if (withRun === 0) return "defs";
+    if (withRun === tools2.length) return "loop";
+    throw new Error(
+      "llm tools must either all define run() (the SDK runs the loop) or none of them (raw toolCalls passthrough)."
+    );
+  }
   function label2(method, input, opts = {}) {
-    const preview = typeof input === "string" ? shorten(input.replace(/\s+/g, " ").trim(), 70) : `${input.length} message${input.length === 1 ? "" : "s"}`;
+    const trimmed = typeof input === "string" ? input.replace(/\s+/g, " ").trim() : "";
+    const preview = typeof input === "string" ? shorten(trimmed, 70) : `${input.length} message${input.length === 1 ? "" : "s"}`;
+    const fullPreview = typeof input === "string" ? trimmed : JSON.stringify(input);
     const output = opts.output?.type === "json" ? " \u2192 json" : "";
-    return `llm.${method}(${q(preview)})${output}`;
+    const tools2 = opts.tools?.length ? ` +${opts.tools.length} tool${opts.tools.length === 1 ? "" : "s"}` : "";
+    return {
+      label: `llm.${method}(${q(preview)})${output}${tools2}`,
+      full: `llm.${method}(${q(fullPreview)})${output}${tools2}`
+    };
   }
   function body2(input, opts = {}) {
     const out = Array.isArray(input) ? { messages: input } : { input };
@@ -652,7 +1324,13 @@
     if (opts.provider !== void 0) out.provider = opts.provider;
     if (opts.system !== void 0) out.system = opts.system;
     if (opts.output !== void 0) out.output = opts.output;
-    if (opts.temperature !== void 0) out.temperature = opts.temperature;
+    if (opts.tools !== void 0) {
+      out.tools = opts.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        schema: t.schema
+      }));
+    }
     if (opts.maxOutputTokens !== void 0) out.maxOutputTokens = opts.maxOutputTokens;
     if (opts.metadata !== void 0) out.metadata = opts.metadata;
     return out;
@@ -662,20 +1340,19 @@
       method: "POST",
       credentials: "include",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body2(input, opts))
+      body: JSON.stringify(body2(input, opts)),
+      signal: opts.signal ?? null
     });
     if (!resp.ok) throw new ApiError(resp.status, await resp.text());
     return await resp.json();
   }
   async function* doStream(input, opts = {}) {
-    if (opts.output?.type === "json") {
-      throw new Error("llm.stream() does not support JSON output; use llm.generate().");
-    }
     const resp = await send(buildUrl("/llm/stream"), {
       method: "POST",
       credentials: "include",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body2(input, opts))
+      body: JSON.stringify(body2(input, opts)),
+      signal: opts.signal ?? null
     });
     if (!resp.ok) throw new ApiError(resp.status, await resp.text());
     if (!resp.body) throw new Error("LLM stream response has no body.");
@@ -702,11 +1379,30 @@
       reader.releaseLock();
     }
   }
+  var wire = { generate: doGenerate, stream: doStream };
   function generate(input, opts = {}) {
-    return track("llm", label2("generate", input, opts), () => doGenerate(input, opts));
+    const mode = toolMode(opts.tools);
+    if (opts.output?.type === "json" && mode === "defs") {
+      throw new Error(
+        "llm.generate() does not support JSON output with run-less tools; add run() handlers or omit tools."
+      );
+    }
+    const { label: lbl, full } = label2("generate", input, opts);
+    if (mode === "loop") {
+      return track("llm", lbl, () => runToolLoop(input, opts, wire), full);
+    }
+    return track("llm", lbl, () => doGenerate(input, opts), full);
   }
   function stream(input, opts = {}) {
-    return trackStream("llm", label2("stream", input, opts), () => doStream(input, opts));
+    const mode = toolMode(opts.tools);
+    if (opts.output?.type === "json" && mode !== "loop") {
+      throw new Error("llm.stream() does not support JSON output; use llm.generate().");
+    }
+    const { label: lbl, full } = label2("stream", input, opts);
+    if (mode === "loop") {
+      return trackStream("llm", lbl, () => streamToolLoop(input, opts, wire), full);
+    }
+    return trackStream("llm", lbl, () => doStream(input, opts), full);
   }
   var llm = { generate, stream };
   var llmProviders = () => track("llm", "llmProviders()", () => call("GET", "/llm/providers"));
@@ -750,13 +1446,16 @@
   // ../sdk/src/queries.ts
   var PARAMS_LABEL_MAX2 = 40;
   var query = (name, params) => {
-    const label3 = `query(${q(name)}${params && Object.keys(params).length ? `, ${shorten(JSON.stringify(params), PARAMS_LABEL_MAX2)}` : ""})`;
+    const paramsJson = params && Object.keys(params).length ? JSON.stringify(params) : "";
+    const label3 = `query(${q(name)}${paramsJson ? `, ${shorten(paramsJson, PARAMS_LABEL_MAX2)}` : ""})`;
+    const full = `query(${q(name)}${paramsJson ? `, ${paramsJson}` : ""})`;
     return track(
       "sql",
       label3,
       () => call("POST", `/queries/${encPath(name)}`, {
         body: { params: params || {} }
-      }).then(toSqlRows)
+      }).then(toSqlRows),
+      full
     );
   };
   var savedQueries = () => track("queries", "savedQueries()", () => call("GET", "/queries"));
@@ -777,12 +1476,14 @@
   var request = (name, path, opts) => {
     const method = (opts?.method || "GET").toUpperCase();
     const label3 = `connector(${q(name)}).fetch(${q(method)} ${q(shorten(path, PATH_LABEL_MAX))})`;
+    const full = `connector(${q(name)}).fetch(${q(method)} ${q(path)})`;
     return track(
       "connector",
       label3,
       () => call("POST", "/service-connectors/request", {
         body: { connector: name, method, path, body: opts?.body }
-      }).then(toResponse)
+      }).then(toResponse),
+      full
     );
   };
   var connector = (name) => ({