@kelloggt/dsh-program-agents 0.0.0-stage → 0.1.1

package/dist/client.js

@@ -0,0 +1,673 @@
+window.__ModuleLoader__.load({id:"@kelloggt/dsh-program-agents",factory:(require)=>{var module={exports:{}};var exports=module.exports;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ProgramAgentsDock: () => ProgramAgentsDock,
+  ProgramAgentsPanel: () => ProgramAgentsPanel,
+  apply: () => apply,
+  inject: () => inject
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/endpoints.ts
+var controls = /[\u0000-\u0020\u007f\\]/;
+function endpointName(value) {
+  return typeof value === "string" && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(value);
+}
+function normalizeEndpointPath(value) {
+  if (value === void 0) return "/";
+  if (typeof value !== "string" || !value.startsWith("/") || value.startsWith("//") || value.length > 4096 || controls.test(value) || /%(?:0[0-9a-f]|1[0-9a-f]|7f|5c)/i.test(value)) throw Error("Endpoint path must be a bounded absolute path, not a URL or authority");
+  const u = new URL(value, "http://endpoint.invalid");
+  if (u.origin !== "http://endpoint.invalid") throw Error("Invalid endpoint path");
+  return u.pathname + u.search + u.hash;
+}
+function normalizeHostname(value) {
+  if (typeof value !== "string" || !value || value.length > 253 || controls.test(value) || /[/?#@%]/.test(value)) throw Error("Invalid endpoint hostname");
+  const bracketed = value.includes(":") && !value.startsWith("[") ? "[" + value + "]" : value;
+  let u;
+  try {
+    u = new URL("http://" + bracketed + "/");
+  } catch {
+    throw Error("Invalid endpoint hostname");
+  }
+  if (u.port || u.username || u.password || u.pathname !== "/" || !u.hostname) throw Error("Hostname must not include a scheme, port or credentials");
+  return u.hostname;
+}
+function endpointUrl(address2, browserHostname) {
+  try {
+    if (!address2 || !endpointName(address2.endpoint) || !["http", "https"].includes(address2.protocol) || !Number.isSafeInteger(address2.port) || address2.port < 1 || address2.port > 65535) return void 0;
+    const host = normalizeHostname(address2.host === "browser" ? browserHostname : address2.host);
+    if (["0.0.0.0", "[::]", "browser"].includes(host)) return void 0;
+    const path = normalizeEndpointPath(address2.path);
+    return new URL(`${address2.protocol}://${host}:${address2.port}${path}`).href;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/client/model.ts
+var CLIENT_LIMITS = { runs: 100, programs: 100, resources: 30, textCharacters: 2e3, frameBytes: 128 * 1024 };
+var states = ["starting", "running", "blocked", "stopping", "stopped", "completed", "failed"];
+var isTerminal = (state) => ["stopped", "completed", "failed"].includes(state);
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function boundedText(value, max = CLIENT_LIMITS.textCharacters) {
+  return typeof value === "string" ? value.slice(0, max) : "";
+}
+function safeResourceUrl(value) {
+  if (typeof value !== "string" || value.length > 8192 || !/^https?:\/\//i.test(value) || /[\u0000-\u0020\u007f\\]/.test(value)) return void 0;
+  try {
+    const url = new URL(value);
+    return (url.protocol === "https:" || url.protocol === "http:") && url.hostname && !url.username && !url.password ? url.href : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resourceLink(item, resource, stale = false, pending, browserHostname) {
+  if (stale || pending || !resource.available || !item.run || !["running", "blocked"].includes(item.run.state)) return void 0;
+  if (resource.endpoint) {
+    if (!resource.address || resource.address.endpoint !== resource.endpoint || resource.address.path !== (resource.path ?? "/")) return void 0;
+    return endpointUrl(resource.address, browserHostname ?? (typeof location === "undefined" ? void 0 : location.hostname));
+  }
+  return safeResourceUrl(resource.url);
+}
+function runControls(state, pending = false, stale = false) {
+  const ready = !pending && !stale;
+  return {
+    start: ready && (state === "configured" || isTerminal(state)),
+    stop: ready && ["starting", "running", "blocked"].includes(state),
+    restart: ready && state !== "configured" && state !== "stopping"
+  };
+}
+function requiredString(value, name) {
+  if (typeof value !== "string" || !value || value.length > 512) throw new Error(`Invalid program snapshot ${name}.`);
+  return value;
+}
+var command = (value) => (Array.isArray(value) ? value : []).slice(0, 100).map((part) => boundedText(part));
+function address(value) {
+  if (!record(value) || !endpointName(value.endpoint) || !["http", "https"].includes(String(value.protocol)) || !Number.isSafeInteger(value.port) || Number(value.port) < 1 || Number(value.port) > 65535 || typeof value.host !== "string") return void 0;
+  try {
+    const host = value.host === "browser" ? "browser" : normalizeHostname(value.host);
+    return { endpoint: value.endpoint, host, protocol: value.protocol, port: Number(value.port), path: normalizeEndpointPath(value.path) };
+  } catch {
+    return void 0;
+  }
+}
+function resources(value) {
+  return (Array.isArray(value) ? value : []).slice(0, CLIENT_LIMITS.resources).flatMap((raw) => {
+    if (!record(raw)) return [];
+    let recipe;
+    if (raw.endpoint !== void 0) {
+      if (!endpointName(raw.endpoint)) return [];
+      try {
+        recipe = { endpoint: raw.endpoint, path: normalizeEndpointPath(raw.path) };
+      } catch {
+        return [];
+      }
+    }
+    const resolved = address(raw.address);
+    return [{
+      id: boundedText(raw.id, 200),
+      title: boundedText(raw.title, 300),
+      type: ["ui", "api", "docs"].includes(String(raw.type)) ? raw.type : "ui",
+      url: boundedText(raw.url, 8192),
+      ...typeof raw.docs === "string" ? { docs: boundedText(raw.docs, 8192) } : {},
+      ...recipe ?? {},
+      ...resolved ? { address: resolved } : {},
+      available: raw.available === true
+    }];
+  });
+}
+function normalizeRun(raw, sessionId) {
+  const id = requiredString(raw.id, "id");
+  if (!Number.isSafeInteger(raw.generation) || raw.generation < 1 || !states.includes(String(raw.state))) throw new Error("Invalid program snapshot state or generation.");
+  return {
+    id,
+    generation: raw.generation,
+    ownerId: sessionId,
+    program: requiredString(raw.program, "program"),
+    label: boundedText(raw.label, 200),
+    state: raw.state,
+    ...typeof raw.name === "string" ? { name: boundedText(raw.name, 200) } : {},
+    ...typeof raw.description === "string" ? { description: boundedText(raw.description) } : {},
+    ...Array.isArray(raw.command) ? { command: command(raw.command) } : {},
+    ...typeof raw.logsPath === "string" ? { logsPath: boundedText(raw.logsPath, 8192) } : {},
+    status: boundedText(raw.status, 200),
+    error: boundedText(raw.error, 240),
+    startedAt: boundedText(raw.startedAt, 100),
+    resources: resources(raw.resources ?? raw.urls)
+  };
+}
+function parseRunList(value, sessionId) {
+  if (!record(value) || !Array.isArray(value.runs) || value.programs !== void 0 && !Array.isArray(value.programs)) throw new Error("Program agents API returned an invalid list.");
+  const scoped = value.runs.filter((raw) => record(raw) && raw.ownerId === sessionId);
+  scoped.sort((left, right) => String(right.startedAt ?? "").localeCompare(String(left.startedAt ?? "")) || Number(right.generation) - Number(left.generation));
+  const newest = /* @__PURE__ */ new Map();
+  for (const raw of scoped) if (!newest.has(String(raw.program))) newest.set(String(raw.program), raw);
+  const first = new Set(newest.values());
+  const ordered = [...first, ...scoped.filter((raw) => !first.has(raw))];
+  const runs = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const raw of ordered.slice(0, CLIENT_LIMITS.runs)) {
+    const run = normalizeRun(raw, sessionId);
+    if (!ids.has(run.id)) {
+      runs.push(run);
+      ids.add(run.id);
+    }
+  }
+  const programs = [];
+  const keys = /* @__PURE__ */ new Set();
+  const definitions = Array.isArray(value.programs) ? value.programs : [];
+  for (const raw of definitions.slice(0, CLIENT_LIMITS.programs)) {
+    if (!record(raw)) throw new Error("Invalid program descriptor.");
+    const program = requiredString(raw.program, "program");
+    if (keys.has(program)) continue;
+    programs.push({ program, name: boundedText(raw.name, 200) || program, description: boundedText(raw.description), command: command(raw.command), urls: resources(raw.urls), ...raw.hasModelSlots === true ? { hasModelSlots: true, modelRevision: boundedText(raw.modelRevision, 2e3) } : {}, ...typeof raw.logsPath === "string" ? { logsPath: boundedText(raw.logsPath, 8192) } : {} });
+    keys.add(program);
+  }
+  const latest = /* @__PURE__ */ new Map();
+  for (const run of runs) if (!latest.has(run.program)) latest.set(run.program, run);
+  const items = programs.map((descriptor) => {
+    const run = latest.get(descriptor.program);
+    latest.delete(descriptor.program);
+    const merged = new Map(descriptor.urls.map((resource) => [resource.id, resource]));
+    for (const resource of run?.resources ?? []) {
+      const configured = merged.get(resource.id);
+      merged.set(resource.id, { ...resource, ...resource.docs === void 0 && configured?.docs !== void 0 ? { docs: configured.docs } : {} });
+    }
+    return { ...descriptor, urls: [...merged.values()].slice(0, CLIENT_LIMITS.resources), ...run ? { run, logsPath: run.logsPath || descriptor.logsPath } : {} };
+  });
+  for (const run of latest.values()) items.push({ program: run.program, name: run.name || run.label || run.program, description: run.description || "", command: run.command ?? [], logsPath: run.logsPath, urls: run.resources, run });
+  return { runs, programs, items: items.slice(0, CLIENT_LIMITS.programs), truncated: scoped.length > CLIENT_LIMITS.runs || definitions.length > CLIENT_LIMITS.programs || items.length > CLIENT_LIMITS.programs };
+}
+
+// src/client/transport.ts
+var ProgramApiError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProgramApiError";
+    this.code = code;
+  }
+};
+var cancelled = () => new ProgramApiError("cancelled", "Program agents request cancelled.");
+async function abortable(operation, signal) {
+  if (signal.aborted) throw cancelled();
+  let onAbort;
+  try {
+    return await Promise.race([operation(), new Promise((_resolve, reject) => {
+      onAbort = () => reject(cancelled());
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) onAbort();
+    })]);
+  } finally {
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+async function consumeSnapshots(response, snapshot, signal) {
+  if (!response.ok || !/^text\/event-stream(?:\s*;|$)/i.test(response.headers.get("content-type") ?? "") || !response.body) throw new ProgramApiError("stream", "Program agents connection unavailable.");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let line = "", event = "", data = [], frameBytes = 0;
+  const abort = () => {
+    void reader.cancel().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  const completeLine = () => {
+    const text = line.endsWith("\r") ? line.slice(0, -1) : line;
+    line = "";
+    if (!text) {
+      if (event === "snapshot" && data.length) snapshot(JSON.parse(data.join("\n")));
+      event = "";
+      data = [];
+      frameBytes = 0;
+    } else if (!text.startsWith(":")) {
+      const separator = text.indexOf(":");
+      const field = separator < 0 ? text : text.slice(0, separator);
+      let value = separator < 0 ? "" : text.slice(separator + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+      if (field === "event") event = value;
+      if (field === "data") data.push(value);
+    }
+  };
+  try {
+    while (!signal.aborted) {
+      const { done, value } = await abortable(() => reader.read(), signal);
+      if (done) break;
+      let start = 0;
+      for (let index = 0; index < value.length; index++) {
+        if (value[index] !== 10) continue;
+        frameBytes += index + 1 - start;
+        if (frameBytes > CLIENT_LIMITS.frameBytes) throw new ProgramApiError("stream", "Program agents snapshot is too large.");
+        line += decoder.decode(value.subarray(start, index), { stream: true });
+        completeLine();
+        start = index + 1;
+      }
+      frameBytes += value.length - start;
+      if (frameBytes > CLIENT_LIMITS.frameBytes) throw new ProgramApiError("stream", "Program agents snapshot is too large.");
+      line += decoder.decode(value.subarray(start), { stream: true });
+    }
+    if (signal.aborted) throw cancelled();
+  } finally {
+    signal.removeEventListener("abort", abort);
+    void reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+function createProgramClient(connection, sessionId, streamingFetch = (input, init) => globalThis.fetch(input, init), timeoutMs = 2e4) {
+  if (!sessionId) throw new Error("Program agents require a selected Session.");
+  const rpc = "rpc" in connection ? connection.rpc : connection;
+  const call = async (method, payload, signal) => {
+    const abort = new AbortController();
+    const cancel = () => abort.abort();
+    signal.addEventListener("abort", cancel, { once: true });
+    if (signal.aborted) abort.abort();
+    const deadline = setTimeout(cancel, timeoutMs);
+    try {
+      const reply = await abortable(() => rpc.call("/api", `programAgents/${method}`, payload, abort.signal), abort.signal);
+      if (!reply.ok) throw new ProgramApiError(reply.error.code, reply.error.message);
+      return reply.value;
+    } catch (error) {
+      if (abort.signal.aborted && !signal.aborted) throw new ProgramApiError("timeout", "Program action timed out. Check status before retrying.");
+      throw error;
+    } finally {
+      clearTimeout(deadline);
+      signal.removeEventListener("abort", cancel);
+    }
+  };
+  return {
+    sessionId,
+    async modelConfiguration(program, signal) {
+      return await call("models", { sessionId, program }, signal);
+    },
+    async setModel(program, slot, selection, revision, signal) {
+      return await call("modelSet", { sessionId, program, slot, selection, revision }, signal);
+    },
+    async list(signal) {
+      return parseRunList(await call("list", { sessionId }, signal), sessionId);
+    },
+    async subscribe(snapshot, signal) {
+      const url = new URL("api/programAgents/events", document.baseURI);
+      const response = await abortable(() => streamingFetch(url, {
+        method: "POST",
+        credentials: "same-origin",
+        redirect: "error",
+        cache: "no-store",
+        headers: { "content-type": "application/json", accept: "text/event-stream" },
+        body: JSON.stringify({ sessionId }),
+        signal
+      }), signal);
+      await consumeSnapshots(response, (value) => {
+        if (!signal.aborted) snapshot(parseRunList(value, sessionId));
+      }, signal);
+    },
+    async action(action, target, signal) {
+      const run = "ownerId" in target ? target : target.run;
+      if (run && run.ownerId !== sessionId) throw new Error("Program does not belong to this Session.");
+      if (action !== "start" && !run) throw new Error("Program has no current run.");
+      await call(action, action === "start" ? { sessionId, program: target.program } : { sessionId, id: run.id, generation: run.generation }, signal);
+    }
+  };
+}
+
+// src/client/view.ts
+var import_react2 = require("react");
+
+// src/client/controller.ts
+var actionKey = (item) => item.program;
+var errorText = (error) => boundedText(error instanceof Error ? error.message : "Connection unavailable.", 180);
+function createPanelController(client, reconnectDelayMs = 1e3) {
+  let state = { runs: [], programs: [], items: [], loading: true, stale: true, truncated: false, pending: {}, actionErrors: {} };
+  const listeners = /* @__PURE__ */ new Set();
+  let active = false, visible = true, epoch = 0, failures = 0;
+  let timer;
+  let stream;
+  const actions = /* @__PURE__ */ new Map();
+  const awaiting = /* @__PURE__ */ new Map();
+  const sameRun = (left, right) => left?.id === right?.id && left?.generation === right?.generation && left?.state === right?.state;
+  const publish = (patch) => {
+    state = { ...state, ...patch };
+    for (const listener of listeners) listener();
+  };
+  const clearTimer = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+  };
+  const invalidate = () => {
+    epoch++;
+    clearTimer();
+    stream?.abort();
+  };
+  function connect() {
+    if (!active || !visible) return;
+    invalidate();
+    const abort = new AbortController();
+    stream = abort;
+    const current = epoch;
+    let baseline = true;
+    publish({ loading: true, stale: true });
+    const latest = () => active && visible && !abort.signal.aborted && current === epoch;
+    void (async () => {
+      try {
+        await client.subscribe((result) => {
+          if (!latest()) return;
+          failures = 0;
+          const errors = Object.fromEntries(Object.entries(state.actionErrors).filter(([key]) => {
+            const before = state.items.find((item) => item.program === key)?.run;
+            const after = result.items.find((item) => item.program === key)?.run;
+            return before?.id === after?.id && before?.generation === after?.generation;
+          }));
+          const pending = { ...state.pending };
+          for (const [key, before] of awaiting) {
+            const after = result.items.find((item) => item.program === key)?.run;
+            if (baseline || !sameRun(before, after)) {
+              awaiting.delete(key);
+              delete pending[key];
+            }
+          }
+          baseline = false;
+          publish({ ...result, loading: false, stale: false, error: void 0, actionErrors: errors, pending });
+        }, abort.signal);
+        if (latest()) throw new Error("Connection interrupted.");
+      } catch (error) {
+        if (!latest()) return;
+        publish({ loading: false, stale: true, error: errorText(error) });
+        abort.abort();
+        epoch++;
+        const delay = Math.min(3e4, Math.max(1, reconnectDelayMs) * 2 ** Math.min(failures++, 5));
+        timer = setTimeout(() => {
+          timer = void 0;
+          connect();
+        }, delay);
+      }
+    })();
+  }
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    start() {
+      if (active) return;
+      active = true;
+      connect();
+    },
+    stop() {
+      active = false;
+      invalidate();
+      for (const action of actions.values()) action.abort();
+      actions.clear();
+      awaiting.clear();
+      publish({ loading: false, stale: true, pending: {} });
+    },
+    setVisible(next) {
+      if (visible === next) return;
+      visible = next;
+      if (next) connect();
+      else {
+        invalidate();
+        publish({ loading: false, stale: true });
+      }
+    },
+    async action(action, target) {
+      const key = actionKey(target);
+      const latest = state.items.find((item) => item.program === target.program);
+      const expected = "ownerId" in target ? target : target.run;
+      if (!active || !visible || !latest || actions.has(key) || state.pending[key] || latest.run?.id !== expected?.id || latest.run?.generation !== expected?.generation || !runControls(latest.run?.state ?? "configured", false, state.stale)[action]) return false;
+      const abort = new AbortController();
+      actions.set(key, abort);
+      publish({ pending: { ...state.pending, [key]: action }, actionErrors: { ...state.actionErrors, [key]: "" } });
+      try {
+        await client.action(action, latest, abort.signal);
+        if (!active || abort.signal.aborted) return false;
+        const after = state.items.find((item) => item.program === key)?.run;
+        if (sameRun(expected, after)) awaiting.set(key, expected);
+        return true;
+      } catch (error) {
+        if (active && !abort.signal.aborted) {
+          publish({ stale: true, actionErrors: { ...state.actionErrors, [key]: errorText(error) } });
+          connect();
+        }
+        return false;
+      } finally {
+        if (actions.get(key) === abort) {
+          actions.delete(key);
+          const next = { ...state.pending };
+          if (!awaiting.has(key)) delete next[key];
+          if (active) publish({ pending: next });
+        }
+      }
+    }
+  };
+}
+
+// src/client/models.ts
+var import_react = require("react");
+var control = { font: "inherit", color: "inherit", background: "var(--dsw-specific-menu, Canvas)", border: "1px solid #8885", borderRadius: 5, padding: "3px 6px", maxWidth: "100%" };
+var routeKey = (route) => JSON.stringify([route.provider, route.model]);
+function Slot({ slot, config, client, program, onSaved }) {
+  const [selected, setSelected] = (0, import_react.useState)(slot.selection), [pending, setPending] = (0, import_react.useState)(false), [error, setError] = (0, import_react.useState)("");
+  (0, import_react.useEffect)(() => {
+    setSelected(slot.selection);
+    setError("");
+  }, [slot.revision]);
+  const model = config.catalog.groups.find((g) => g.id === selected.provider)?.models.find((m) => m.id === selected.model), unavailable = !model;
+  const save = async (reset = false) => {
+    setPending(true);
+    setError("");
+    try {
+      await client.setModel(program, slot.id, reset ? null : selected, slot.revision, new AbortController().signal);
+      onSaved();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Model change failed");
+    } finally {
+      setPending(false);
+    }
+  };
+  return (0, import_react.createElement)(
+    "fieldset",
+    { style: { border: "1px solid #8884", borderRadius: 6, margin: "6px 0", padding: 8 }, disabled: pending },
+    (0, import_react.createElement)("legend", null, slot.id),
+    (0, import_react.createElement)("div", { style: { opacity: 0.8, marginBottom: 5 } }, slot.description),
+    (0, import_react.createElement)(
+      "div",
+      { style: { display: "flex", flexWrap: "wrap", gap: 6, alignItems: "center" } },
+      (0, import_react.createElement)(
+        "label",
+        null,
+        "Model ",
+        (0, import_react.createElement)(
+          "select",
+          { "aria-label": `Model for ${slot.id}`, style: control, value: routeKey(selected), onChange: (event) => {
+            const [provider, model2] = JSON.parse(event.target.value);
+            setSelected({ provider, model: model2 });
+          } },
+          unavailable ? (0, import_react.createElement)("option", { value: routeKey(selected) }, `${selected.provider} / ${selected.model} (unavailable)`) : null,
+          ...config.catalog.groups.map((group) => (0, import_react.createElement)("optgroup", { key: group.id, label: group.name }, ...group.models.map((item) => (0, import_react.createElement)("option", { key: item.id, value: routeKey({ provider: group.id, model: item.id }) }, item.name))))
+        ),
+        (0, import_react.createElement)("label", null, "Reasoning ", (0, import_react.createElement)(
+          "select",
+          { "aria-label": `Reasoning for ${slot.id}`, style: control, value: selected.reasoningEffort ?? "", onChange: (event) => setSelected(({ provider, model: model2 }) => ({ provider, model: model2, ...event.target.value ? { reasoningEffort: event.target.value } : {} })) },
+          (0, import_react.createElement)("option", { value: "" }, "Model default"),
+          ...selected.reasoningEffort && !model?.reasoning?.efforts.some((e) => e.id === selected.reasoningEffort) ? [(0, import_react.createElement)("option", { key: "unavailable", value: selected.reasoningEffort }, selected.reasoningEffort + " (unavailable)")] : [],
+          ...(model?.reasoning?.efforts ?? []).map((e) => (0, import_react.createElement)("option", { key: e.id, value: e.id }, e.name))
+        ))
+      ),
+      (0, import_react.createElement)("button", { type: "button", style: control, onClick: () => void save(), disabled: pending || unavailable }, pending ? "Saving\u2026" : "Save"),
+      (0, import_react.createElement)("button", { type: "button", style: control, onClick: () => void save(true), disabled: pending || !slot.overridden }, "Use program default")
+    ),
+    (0, import_react.createElement)("div", { style: { opacity: 0.65, fontSize: 11, marginTop: 5 } }, `Default: ${slot.default.provider} / ${slot.default.model}${slot.default.reasoningEffort ? " / " + slot.default.reasoningEffort : ""}${slot.overridden ? " \xB7 User override" : ""}`),
+    unavailable ? (0, import_react.createElement)("p", { role: "status" }, "Saved model is unavailable. It will not silently fall back.") : null,
+    error ? (0, import_react.createElement)("p", { role: "alert" }, error) : null
+  );
+}
+function ProgramModels({ client, program, revision }) {
+  const [config, setConfig] = (0, import_react.useState)(), [error, setError] = (0, import_react.useState)(""), [refresh, setRefresh] = (0, import_react.useState)(0);
+  (0, import_react.useEffect)(() => {
+    const abort = new AbortController();
+    setError("");
+    void client.modelConfiguration(program, abort.signal).then((value) => {
+      if (!abort.signal.aborted) setConfig(value);
+    }, (e) => {
+      if (!abort.signal.aborted) setError(e instanceof Error ? e.message : "Model configuration unavailable");
+    });
+    return () => abort.abort();
+  }, [client, program, revision, refresh]);
+  return (0, import_react.createElement)(
+    "div",
+    { "aria-label": "Program model configuration", style: { marginTop: 6 } },
+    (0, import_react.createElement)("p", { style: { opacity: 0.75 } }, "Selections affect future model-slot calls and newly created conversations. Existing conversations retain their model."),
+    error ? (0, import_react.createElement)("p", { role: "alert" }, error) : null,
+    !config && !error ? (0, import_react.createElement)("p", null, "Loading models\u2026") : null,
+    ...(config?.slots ?? []).map((slot) => (0, import_react.createElement)(Slot, { key: slot.id, slot, config, client, program, onSaved: () => setRefresh((n) => n + 1) })),
+    ...(config?.catalog.failures ?? []).map((f) => (0, import_react.createElement)("p", { key: f.id, role: "status" }, `${f.name}: ${f.message}`))
+  );
+}
+
+// src/client/view.ts
+var panelStyle = {
+  boxSizing: "border-box",
+  width: "100%",
+  maxWidth: "var(--dsh-composer-card-max-width, 960px)",
+  margin: "0 auto 4px",
+  border: "1px solid var(--dsw-alias-border-l1, #8884)",
+  borderRadius: 8,
+  background: "var(--dsw-specific-menu, Canvas)",
+  color: "var(--dsw-alias-label-primary, CanvasText)",
+  fontSize: 12
+};
+var rowStyle = { display: "flex", gap: 8, alignItems: "center", minWidth: 0 };
+var buttonStyle = { font: "inherit", color: "inherit", background: "transparent", border: "1px solid var(--dsw-alias-border-l1, #8885)", borderRadius: 5, padding: "2px 6px", cursor: "pointer", whiteSpace: "nowrap" };
+var mutedStyle = { opacity: 0.65, fontSize: 11 };
+var linkStyle = { color: "var(--dsw-alias-link-primary, LinkText)", whiteSpace: "nowrap" };
+var errorStyle = { color: "var(--dsw-alias-state-error-primary, #bc3333)", fontSize: 11, margin: "3px 0 0", overflowWrap: "anywhere" };
+function button(label, disabled, onClick, extra = {}) {
+  return (0, import_react2.createElement)("button", { type: "button", style: { ...buttonStyle, opacity: disabled ? 0.5 : 1 }, disabled, onClick, ...extra }, label);
+}
+function ProgramRow({ item, state, controller, client }) {
+  const key = actionKey(item), pending = state.pending[key];
+  const status = item.run?.state ?? "configured";
+  const controls2 = runControls(status, Boolean(pending), state.stale);
+  const [more, setMore] = (0, import_react2.useState)(false);
+  const [models, setModels] = (0, import_react2.useState)(false);
+  const [copied, setCopied] = (0, import_react2.useState)("");
+  const localDocs = [...new Set(item.urls.flatMap((resource) => [
+    ...resource.docs && !safeResourceUrl(resource.docs) ? [resource.docs] : [],
+    ...resource.type === "docs" && /^(?:\/|[A-Za-z]:[\\/])/.test(resource.url) && !safeResourceUrl(resource.url) ? [resource.url] : []
+  ]))];
+  const hasMore = Boolean(item.description || item.command.length || item.logsPath || localDocs.length);
+  const perform = (action) => {
+    void controller.action(action, item);
+  };
+  const copy = (text) => {
+    if (typeof navigator.clipboard?.writeText === "function") void navigator.clipboard.writeText(text).then(() => setCopied(text), () => {
+    });
+  };
+  return (0, import_react2.createElement)(
+    "article",
+    { "data-program-key": item.program, style: { padding: "6px 9px", borderTop: "1px solid var(--dsw-alias-border-l1, #8883)" } },
+    (0, import_react2.createElement)(
+      "div",
+      { style: rowStyle },
+      (0, import_react2.createElement)("strong", { title: item.name, style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", flex: "1 1 100px" } }, item.name),
+      (0, import_react2.createElement)("span", { "data-program-state": status, title: item.run?.status, style: mutedStyle }, status),
+      (0, import_react2.createElement)("span", { "aria-label": "Program resources", style: { ...rowStyle, gap: 6, flexWrap: "wrap" } }, ...item.urls.flatMap((resource, index) => {
+        const href = resourceLink(item, resource, state.stale, pending);
+        const label = resource.type.toUpperCase();
+        const docsHref = resource.docs && safeResourceUrl(resource.docs);
+        return [
+          href ? (0, import_react2.createElement)("a", { key: `${index}:url`, href, target: "_blank", rel: "noopener noreferrer", referrerPolicy: "no-referrer", title: resource.title, style: linkStyle }, label) : (0, import_react2.createElement)("span", { key: `${index}:url`, "aria-disabled": true, title: resource.title, style: mutedStyle }, label),
+          ...docsHref && resource.type !== "docs" ? [href ? (0, import_react2.createElement)("a", { key: `${index}:docs`, href: docsHref, target: "_blank", rel: "noopener noreferrer", referrerPolicy: "no-referrer", style: linkStyle }, "Docs") : (0, import_react2.createElement)("span", { key: `${index}:docs`, "aria-disabled": true, style: mutedStyle }, "Docs")] : []
+        ];
+      })),
+      status === "configured" || ["stopped", "completed", "failed"].includes(status) ? button(pending === "start" ? "Starting\u2026" : "Start", !controls2.start, () => perform("start")) : null,
+      status !== "configured" && !["stopped", "completed", "failed"].includes(status) ? button(pending === "stop" ? "Stopping\u2026" : "Stop", !controls2.stop, () => perform("stop")) : null,
+      status !== "configured" ? button(pending === "restart" ? "Restarting\u2026" : "Restart", !controls2.restart, () => perform("restart")) : null,
+      item.hasModelSlots && client.modelConfiguration && client.setModel ? button("Models", state.stale, () => setModels(!models), { "aria-expanded": models, "aria-label": `Configure models for ${item.name}` }) : null,
+      hasMore ? button("More", false, () => setMore(!more), { "aria-expanded": more, "aria-label": `More about ${item.name}`, style: { ...buttonStyle, border: 0, padding: "2px 0", ...mutedStyle } }) : null
+    ),
+    state.actionErrors[key] || item.run?.error ? (0, import_react2.createElement)("p", { role: "alert", style: errorStyle }, state.actionErrors[key] || item.run?.error) : null,
+    models && item.hasModelSlots ? (0, import_react2.createElement)(ProgramModels, { client, program: item.program, revision: item.modelRevision }) : null,
+    more ? (0, import_react2.createElement)(
+      "div",
+      { "aria-label": `${item.name} details`, style: { ...mutedStyle, marginTop: 5, overflowWrap: "anywhere" } },
+      item.description ? (0, import_react2.createElement)("div", null, item.description) : null,
+      item.command.length ? (0, import_react2.createElement)("div", null, (0, import_react2.createElement)("code", null, item.command.join(" "))) : null,
+      item.logsPath ? (0, import_react2.createElement)("div", null, "Logs: ", (0, import_react2.createElement)("code", null, item.logsPath)) : null,
+      ...localDocs.map((path, index) => (0, import_react2.createElement)("div", { key: index }, "Docs: ", (0, import_react2.createElement)("code", null, path), " ", button(copied === path ? "Copied" : "Copy", false, () => copy(path))))
+    ) : null
+  );
+}
+function ProgramAgentsPanel({ client, reconnectDelayMs }) {
+  const controller = (0, import_react2.useMemo)(() => createPanelController(client, reconnectDelayMs), [client, reconnectDelayMs]);
+  const state = (0, import_react2.useSyncExternalStore)(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+  (0, import_react2.useEffect)(() => {
+    const changed = () => controller.setVisible(document.visibilityState !== "hidden");
+    changed();
+    controller.start();
+    document.addEventListener("visibilitychange", changed);
+    return () => {
+      document.removeEventListener("visibilitychange", changed);
+      controller.stop();
+    };
+  }, [controller]);
+  const [open, setOpen] = (0, import_react2.useState)(false);
+  return (0, import_react2.createElement)(
+    "section",
+    { "aria-label": "Program agents", "data-session-id": client.sessionId, style: panelStyle },
+    (0, import_react2.createElement)(
+      "div",
+      { style: { ...rowStyle, padding: "3px 8px" } },
+      button(`${open ? "\u25BE" : "\u25B8"} Program agents (${state.items.length})`, false, () => setOpen(!open), { "aria-expanded": open, style: { ...buttonStyle, border: 0, flex: 1, textAlign: "left", padding: "2px 0" } }),
+      state.stale ? (0, import_react2.createElement)("span", { role: "status", title: state.error, style: mutedStyle }, state.error ? "Reconnecting\u2026" : state.loading ? "Connecting\u2026" : "Paused") : null
+    ),
+    open ? (0, import_react2.createElement)(
+      "div",
+      { "data-program-foldout": true, style: { maxHeight: "min(240px, 35vh)", overflowY: "auto", overscrollBehavior: "contain" } },
+      !state.items.length && !state.loading ? (0, import_react2.createElement)("div", { style: { padding: "5px 9px", ...mutedStyle } }, "No programs configured.") : null,
+      state.truncated ? (0, import_react2.createElement)("div", { style: { padding: "3px 9px", ...mutedStyle } }, "Showing the most recent programs.") : null,
+      ...state.items.map((item) => (0, import_react2.createElement)(ProgramRow, { key: item.program, item, state, controller, client }))
+    ) : null
+  );
+}
+function ProgramAgentsDock({ programClient }) {
+  return (0, import_react2.createElement)(ProgramAgentsPanel, { key: programClient.sessionId, client: programClient });
+}
+
+// src/client/index.ts
+var inject = ["slots", "connection"];
+function apply(ctx) {
+  ctx.slots.inject("conversation.input.dock", () => ctx.slots.register({
+    name: "conversation.input.dock",
+    id: "program-agents",
+    order: 30,
+    inject: (sessionId) => ({ programClient: createProgramClient(ctx.connection, sessionId) })
+  }, ProgramAgentsDock));
+}
+
+return module.exports;}});