@cubos/agent-sdk 0.0.1136563

package/dist/index.js

@@ -0,0 +1,1826 @@
+// src/errors.ts
+class AgentError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentError";
+  }
+}
+
+class AgentApiError extends AgentError {
+  status;
+  requestId;
+  body;
+  constructor(message, status, requestId = null, body = "") {
+    super(message);
+    this.name = "AgentApiError";
+    this.status = status;
+    this.requestId = requestId;
+    this.body = body;
+  }
+  json() {
+    try {
+      return JSON.parse(this.body);
+    } catch {
+      return;
+    }
+  }
+  get isAuthError() {
+    return this.status === 401 || this.status === 403;
+  }
+  get isNotFound() {
+    return this.status === 404;
+  }
+  get isConflict() {
+    return this.status === 409;
+  }
+  get isRetryable() {
+    return this.status === 429 || this.status >= 500;
+  }
+}
+
+class AgentConfigError extends AgentError {
+  constructor(message) {
+    super(message);
+    this.name = "AgentConfigError";
+  }
+}
+
+class AgentNetworkError extends AgentError {
+  cause;
+  timedOut;
+  constructor(message, cause, timedOut = false) {
+    super(message);
+    this.name = "AgentNetworkError";
+    this.cause = cause;
+    this.timedOut = timedOut;
+  }
+}
+var DEFAULT_MESSAGES = {
+  400: "Invalid request.",
+  401: "Not authenticated.",
+  403: "Not allowed.",
+  404: "Not found.",
+  409: "Conflicts with the current state.",
+  413: "Payload too large.",
+  429: "Rate limited."
+};
+async function raiseForStatus(res, fallback) {
+  if (res.ok)
+    return;
+  let detail = "";
+  try {
+    detail = await res.text();
+  } catch {
+    detail = "";
+  }
+  const base = DEFAULT_MESSAGES[res.status] ?? fallback;
+  throw new AgentApiError(detail ? `${base} (${detail.slice(0, 500)})` : base, res.status, res.headers.get("x-request-id"), detail);
+}
+
+// src/sse.ts
+var MAX_BACKOFF_MS = 30000;
+
+class Fatal extends Error {
+  cause;
+  constructor(cause) {
+    super("fatal stream error");
+    this.cause = cause;
+  }
+}
+async function readSse(opts) {
+  const doFetch = opts.fetchImpl ?? globalThis.fetch;
+  let lastEventId = opts.lastEventId;
+  let attempt = 0;
+  while (!opts.signal.aborted) {
+    let madeProgress = false;
+    try {
+      const headers = {
+        ...await opts.headers?.(),
+        Accept: "text/event-stream"
+      };
+      if (lastEventId !== undefined)
+        headers["Last-Event-ID"] = lastEventId;
+      const res = await doFetch(opts.url, { headers, signal: opts.signal });
+      if (opts.signal.aborted)
+        return;
+      if (res.ok && res.body)
+        opts.onOpen?.();
+      if (!res.ok || !res.body) {
+        if (res.status >= 400 && res.status < 500) {
+          await raiseForStatus(res, `Could not open ${opts.url}.`).catch((err) => {
+            throw new Fatal(err);
+          });
+          return;
+        }
+        throw new Error(`stream open failed with HTTP ${res.status}`);
+      }
+      for await (const frame of frames(res.body, opts.signal)) {
+        const parsed = parseFrame(frame, opts.event);
+        if (parsed === null)
+          continue;
+        if (parsed.id !== null)
+          lastEventId = parsed.id;
+        opts.onEvent(parsed.data, parsed.event);
+        madeProgress = true;
+      }
+    } catch (err) {
+      if (opts.signal.aborted)
+        return;
+      if (err instanceof Fatal)
+        throw err.cause;
+      opts.onError?.(err);
+    }
+    if (opts.signal.aborted)
+      return;
+    if (madeProgress)
+      attempt = 0;
+    const delayMs = Math.min(MAX_BACKOFF_MS, 1000 * 2 ** attempt);
+    attempt += 1;
+    await sleep(delayMs, opts.signal);
+  }
+}
+async function* frames(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (!signal.aborted) {
+      const { value, done } = await reader.read();
+      if (done)
+        return;
+      buffer += decoder.decode(value, { stream: true });
+      for (;; ) {
+        const sep = buffer.indexOf(`
+
+`);
+        if (sep === -1)
+          break;
+        yield buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => {});
+  }
+}
+function parseFrame(frame, expectedEvent) {
+  let dataLine = null;
+  let id = null;
+  let eventName = "message";
+  for (const line of frame.split(`
+`)) {
+    if (line.startsWith(":"))
+      continue;
+    if (line.startsWith("data:"))
+      dataLine = line.slice(5).trimStart();
+    else if (line.startsWith("event:"))
+      eventName = line.slice(6).trim();
+    else if (line.startsWith("id:"))
+      id = line.slice(3).trim();
+  }
+  const wanted = typeof expectedEvent === "string" ? eventName === expectedEvent : expectedEvent.includes(eventName);
+  if (!wanted || dataLine === null)
+    return null;
+  try {
+    return { data: JSON.parse(dataLine), id, event: eventName };
+  } catch {
+    return null;
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/http.ts
+var DEFAULT_TIMEOUT_MS = 30000;
+var DEFAULT_MAX_RETRIES = 2;
+var MAX_RETRY_WAIT_MS = 20000;
+function parseRetryAfter(header) {
+  if (!header)
+    return null;
+  const seconds = Number(header.trim());
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const date = Date.parse(header);
+  if (Number.isNaN(date))
+    return null;
+  return Math.max(0, date - Date.now());
+}
+function sleep2(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("Aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Aborted"));
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function buildQuery(query) {
+  if (!query)
+    return "";
+  const search = new URLSearchParams;
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined)
+      search.set(key, String(value));
+  }
+  const qs = search.toString();
+  return qs ? `?${qs}` : "";
+}
+function normalizeBaseUrl(baseUrl) {
+  if (typeof baseUrl !== "string") {
+    throw new AgentConfigError("baseUrl is required, e.g. https://agent.acme.com");
+  }
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (trimmed === "")
+    return "";
+  if (!/^https?:\/\//i.test(trimmed)) {
+    throw new AgentConfigError(`baseUrl must start with http:// or https:// (got ${JSON.stringify(baseUrl)}).`);
+  }
+  try {
+    new URL(trimmed);
+  } catch {
+    throw new AgentConfigError(`baseUrl is not a valid URL (got ${JSON.stringify(baseUrl)}).`);
+  }
+  return trimmed;
+}
+function combineSignals(caller, timeout) {
+  if (!caller)
+    return timeout;
+  const anyOf = AbortSignal.any;
+  if (typeof anyOf === "function")
+    return anyOf([caller, timeout]);
+  const controller = new AbortController;
+  const abort = () => controller.abort();
+  if (caller.aborted || timeout.aborted)
+    controller.abort();
+  caller.addEventListener("abort", abort, { once: true });
+  timeout.addEventListener("abort", abort, { once: true });
+  return controller.signal;
+}
+function createTransport(baseUrl, auth, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS, maxRetries = DEFAULT_MAX_RETRIES) {
+  const root = normalizeBaseUrl(baseUrl);
+  async function authHeader(forceRefresh) {
+    if (!("apiKey" in auth))
+      return `Bearer ${await auth.getToken({ forceRefresh })}`;
+    const key = typeof auth.apiKey === "function" ? await auth.apiKey() : auth.apiKey;
+    return `Bearer ${key}`;
+  }
+  async function send(method, path, opts, retry) {
+    const headers = { Authorization: await authHeader(retry) };
+    const isForm = typeof FormData !== "undefined" && opts.body instanceof FormData;
+    let body;
+    if (isForm) {
+      body = opts.body;
+    } else if (opts.body !== undefined) {
+      body = JSON.stringify(opts.body);
+      headers["Content-Type"] = "application/json";
+    }
+    const timer = timeoutMs > 0 && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(timeoutMs) : undefined;
+    const signal = timer ? combineSignals(opts.signal, timer) : opts.signal;
+    const url = `${root}${path}${buildQuery(opts.query)}`;
+    try {
+      return await fetchImpl(url, { method, headers, body, signal });
+    } catch (err) {
+      if (opts.signal?.aborted)
+        throw err;
+      if (timer?.aborted) {
+        throw new AgentNetworkError(`Request to ${url} timed out after ${timeoutMs}ms.`, err, true);
+      }
+      throw new AgentNetworkError(`Could not reach ${url}. Check the base URL, that the server is running, and CORS.`, err);
+    }
+  }
+  async function once(method, path, opts = {}) {
+    let attempt = 0;
+    for (;; ) {
+      let res = await send(method, path, opts, false);
+      if (res.status === 401 && "getToken" in auth) {
+        res = await send(method, path, opts, true);
+      }
+      if (res.status !== 429 || attempt >= maxRetries)
+        return res;
+      const waitMs = parseRetryAfter(res.headers.get("retry-after"));
+      if (waitMs === null || waitMs > MAX_RETRY_WAIT_MS)
+        return res;
+      attempt += 1;
+      await sleep2(waitMs, opts.signal);
+    }
+  }
+  return {
+    fetchImpl,
+    url: (path, query) => `${root}${path}${buildQuery(query)}`,
+    async streamHeaders() {
+      return { Authorization: await authHeader(false) };
+    },
+    fetchRaw: once,
+    async request(method, path, opts = {}) {
+      const res = await once(method, path, opts);
+      await raiseForStatus(res, `${method} ${path} failed.`);
+      if (opts.raw || res.status === 204)
+        return;
+      return await res.json();
+    }
+  };
+}
+
+// src/admin/paths.ts
+var enc = encodeURIComponent;
+var tenantPath = (tenantSlug) => `/api/v1/tenants/${enc(tenantSlug)}`;
+function withoutNoopRename(input, currentSlug) {
+  if (input.slug && input.slug === currentSlug)
+    return { ...input, slug: undefined };
+  return input;
+}
+
+// src/admin/agents.ts
+function agentsApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/agents`;
+  const agent = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", agent(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", agent(currentSlug), {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", agent(slug), { raw: true }),
+    countTokens: (slug, input, signal) => t.request("POST", `${agent(slug)}/count-tokens`, {
+      body: input,
+      signal
+    }),
+    listMcps: (agentSlug, signal) => t.request("GET", `${agent(agentSlug)}/mcps`, { signal }),
+    addMcp: (agentSlug, mcpSlug) => t.request("PUT", `${agent(agentSlug)}/mcps/${enc(mcpSlug)}`, { raw: true }),
+    removeMcp: (agentSlug, mcpSlug) => t.request("DELETE", `${agent(agentSlug)}/mcps/${enc(mcpSlug)}`, { raw: true }),
+    updateMcpTools: (agentSlug, mcpSlug, enabledTools) => t.request("PATCH", `${agent(agentSlug)}/mcps/${enc(mcpSlug)}`, {
+      body: { enabled_tools: enabledTools },
+      raw: true
+    }),
+    replaceMcpRoles: (agentSlug, mcpSlug, roleSlugs) => t.request("PUT", `${agent(agentSlug)}/mcps/${enc(mcpSlug)}/roles`, {
+      body: { role_slugs: roleSlugs },
+      raw: true
+    }),
+    updateMcpRoleTools: (agentSlug, mcpSlug, roleSlug, enabledTools) => t.request("PATCH", `${agent(agentSlug)}/mcps/${enc(mcpSlug)}/roles/${enc(roleSlug)}`, {
+      body: { enabled_tools: enabledTools },
+      raw: true
+    }),
+    listSkills: (agentSlug, signal) => t.request("GET", `${agent(agentSlug)}/skills`, { signal }),
+    addSkill: (agentSlug, skillSlug) => t.request("PUT", `${agent(agentSlug)}/skills/${enc(skillSlug)}`, { raw: true }),
+    removeSkill: (agentSlug, skillSlug) => t.request("DELETE", `${agent(agentSlug)}/skills/${enc(skillSlug)}`, { raw: true }),
+    replaceSkillRoles: (agentSlug, skillSlug, roleSlugs) => t.request("PUT", `${agent(agentSlug)}/skills/${enc(skillSlug)}/roles`, {
+      body: { role_slugs: roleSlugs },
+      raw: true
+    }),
+    listTaskTemplates: (agentSlug, signal) => t.request("GET", `${agent(agentSlug)}/task-templates`, {
+      signal
+    }),
+    addTaskTemplate: (agentSlug, templateSlug) => t.request("PUT", `${agent(agentSlug)}/task-templates/${enc(templateSlug)}`, {
+      raw: true
+    }),
+    removeTaskTemplate: (agentSlug, templateSlug) => t.request("DELETE", `${agent(agentSlug)}/task-templates/${enc(templateSlug)}`, {
+      raw: true
+    }),
+    replaceTaskTemplateRoles: (agentSlug, templateSlug, roleSlugs) => t.request("PUT", `${agent(agentSlug)}/task-templates/${enc(templateSlug)}/roles`, {
+      body: { role_slugs: roleSlugs },
+      raw: true
+    }),
+    listAutoCallTools: (agentSlug, signal) => t.request("GET", `${agent(agentSlug)}/auto-call-tools`, {
+      signal
+    }),
+    putAutoCallTools: (agentSlug, tools) => t.request("PUT", `${agent(agentSlug)}/auto-call-tools`, {
+      body: { tools },
+      raw: true
+    })
+  };
+}
+
+// src/admin/ai-providers.ts
+function aiProvidersApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/ai-providers`;
+  const provider = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", provider(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", provider(currentSlug), {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", provider(slug), { raw: true }),
+    listModels: (slug, signal) => t.request("GET", `${provider(slug)}/models`, { signal }),
+    refreshModels: (slug) => t.request("POST", `${provider(slug)}/models/refresh`),
+    updateModel: (slug, modelId, input) => t.request("PATCH", `${provider(slug)}/models/${enc(modelId)}`, {
+      body: input,
+      raw: true
+    })
+  };
+}
+
+// src/admin/channels.ts
+function channelsApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/channels`;
+  const channel = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", channel(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (slug, input) => t.request("PATCH", channel(slug), { body: input }),
+    delete: (slug) => t.request("DELETE", channel(slug), { raw: true }),
+    rotateSecret: (slug) => t.request("POST", `${channel(slug)}/rotate-secret`),
+    listComponentLibraries: (slug, signal) => t.request("GET", `${channel(slug)}/component-libraries`, {
+      signal
+    }),
+    setComponentLibraries: (slug, libraries) => t.request("PUT", `${channel(slug)}/component-libraries`, {
+      body: { libraries }
+    }),
+    listDeadLetters: (slug, signal) => t.request("GET", `${channel(slug)}/dead-letters`, { signal }),
+    pairWhatsapp: (slug, input) => t.request("POST", `${channel(slug)}/whatsapp/pair`, {
+      body: input
+    })
+  };
+}
+
+// src/client-tools.ts
+var DEFAULT_CLAIM_TTL_SECONDS = 70;
+var SUBMIT_ATTEMPTS = 5;
+function serveClientTools(t, conversationPath, conversationId, options) {
+  const controller = new AbortController;
+  const stop = () => controller.abort();
+  if (options.signal) {
+    if (options.signal.aborted)
+      stop();
+    else
+      options.signal.addEventListener("abort", stop, { once: true });
+  }
+  const claimant = options.claimant ?? `sdk-${randomId()}`;
+  const ttl = options.claimTtlSeconds ?? DEFAULT_CLAIM_TTL_SECONDS;
+  let basePath;
+  const resolveBase = async () => {
+    basePath ??= await conversationPath();
+    return basePath;
+  };
+  const inFlight = new Set;
+  const running = new Set;
+  const track = (p) => {
+    running.add(p);
+    p.finally(() => running.delete(p)).catch(() => {});
+  };
+  const done = (async () => {
+    try {
+      await run();
+    } catch (err) {
+      stop();
+      while (running.size > 0)
+        await Promise.allSettled([...running]);
+      throw err;
+    }
+  })();
+  async function run() {
+    const base = await resolveBase();
+    if (options.declare !== false) {
+      await t.request("PUT", `${base}/client-tools`, {
+        body: { tools: declarations(options.tools) },
+        signal: controller.signal
+      });
+    }
+    if (options.watch === false) {
+      track(guard(drain));
+      await stopped();
+      while (running.size > 0)
+        await Promise.allSettled([...running]);
+      return;
+    }
+    await readSse({
+      url: t.url(`${base}/events/stream`),
+      event: "conversation_event",
+      headers: () => t.streamHeaders(),
+      fetchImpl: t.fetchImpl,
+      signal: controller.signal,
+      onError: options.onError,
+      onOpen: () => {
+        track(guard(drain));
+      },
+      onEvent: (ev) => {
+        if (ev.event_type !== "client_tool_call")
+          return;
+        track(guard(drain));
+      }
+    });
+    while (running.size > 0)
+      await Promise.allSettled([...running]);
+  }
+  async function drain() {
+    if (controller.signal.aborted)
+      return;
+    const base = await resolveBase();
+    const calls = await t.request("GET", `${base}/client-tool-calls`, {
+      signal: controller.signal
+    });
+    for (const call of calls) {
+      if (inFlight.has(call.tool_call_id))
+        continue;
+      const tool = options.tools[call.tool_name];
+      if (!tool)
+        continue;
+      inFlight.add(call.tool_call_id);
+      track(guard(() => execute(call, tool)));
+    }
+  }
+  async function execute(call, tool) {
+    const id = call.tool_call_id;
+    const base = await resolveBase();
+    try {
+      if (!await acquireClaim(call))
+        return;
+      const keepAlive = setInterval(() => {
+        t.request("POST", `${base}/client-tool-calls/${id}/claim`, {
+          body: { claimant, ttl_seconds: ttl }
+        }).catch(() => {});
+      }, Math.max(1000, ttl * 1000 / 2));
+      let body;
+      try {
+        const result = await tool.handler(call.arguments, {
+          toolCallId: id,
+          conversationId,
+          signal: controller.signal
+        });
+        body = { result: result === undefined ? null : result, claimant };
+      } catch (err) {
+        if (controller.signal.aborted) {
+          clearInterval(keepAlive);
+          await t.request("DELETE", `${base}/client-tool-calls/${id}/claim`, {
+            query: { claimant },
+            raw: true
+          }).catch(() => {});
+          return;
+        }
+        options.onError?.(err);
+        body = { error: errorText(err), claimant };
+      } finally {
+        clearInterval(keepAlive);
+      }
+      await submitWithRetry(id, body);
+    } finally {
+      inFlight.delete(id);
+    }
+  }
+  async function acquireClaim(call) {
+    const base = await resolveBase();
+    const deadline = Date.parse(call.deadline_at);
+    while (!controller.signal.aborted) {
+      try {
+        await t.request("POST", `${base}/client-tool-calls/${call.tool_call_id}/claim`, { body: { claimant, ttl_seconds: ttl }, signal: controller.signal });
+        return true;
+      } catch (err) {
+        if (!(err instanceof AgentApiError))
+          throw err;
+        if (err.status === 410 || err.status === 404)
+          return false;
+        if (err.status !== 409)
+          throw err;
+        const held = err.json()?.claim_expires_at;
+        const until = held ? Date.parse(held) : Date.now() + ttl * 1000;
+        const wakeAt = Number.isFinite(deadline) ? Math.min(until, deadline) : until;
+        await sleep3(Math.max(250, wakeAt - Date.now()), controller.signal);
+      }
+    }
+    return false;
+  }
+  async function submitWithRetry(id, body) {
+    const base = await resolveBase();
+    for (let attempt = 0;; attempt++) {
+      try {
+        await t.request("POST", `${base}/client-tool-calls/${id}/result`, {
+          body,
+          raw: true
+        });
+        return;
+      } catch (err) {
+        const status = err instanceof AgentApiError ? err.status : 0;
+        if (status === 410)
+          return;
+        if (status >= 400 && status < 500)
+          throw err;
+        if (attempt >= SUBMIT_ATTEMPTS - 1 || controller.signal.aborted)
+          throw err;
+        options.onError?.(err);
+        await sleep3(Math.min(8000, 250 * 2 ** attempt), controller.signal);
+      }
+    }
+  }
+  async function guard(fn) {
+    try {
+      await fn();
+    } catch (err) {
+      if (!controller.signal.aborted)
+        options.onError?.(err);
+    }
+  }
+  function stopped() {
+    if (controller.signal.aborted)
+      return Promise.resolve();
+    return new Promise((resolve) => {
+      controller.signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+  }
+  return {
+    stop,
+    poke: () => {
+      if (!controller.signal.aborted)
+        track(guard(drain));
+    },
+    done
+  };
+}
+function declarations(tools) {
+  return Object.entries(tools).map(([name, tool]) => ({
+    name,
+    description: tool.description ?? "",
+    input_schema: tool.inputSchema ?? { type: "object" },
+    output_schema: tool.outputSchema,
+    read_only_hint: tool.readOnlyHint,
+    destructive_hint: tool.destructiveHint,
+    idempotent_hint: tool.idempotentHint,
+    timeout_seconds: tool.timeoutSeconds
+  }));
+}
+function errorText(err) {
+  if (err instanceof Error)
+    return err.message;
+  return String(err);
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function randomId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+// src/admin/client-tools.ts
+function clientToolsApi(t, tenantSlug) {
+  const base = (convId) => `${tenantPath(tenantSlug)}/conversations/${enc(convId)}`;
+  const tools = (convId) => `${base(convId)}/client-tools`;
+  const calls = (convId) => `${base(convId)}/client-tool-calls`;
+  return {
+    serve: (convId, options) => serveClientTools(t, async () => base(convId), convId, options),
+    list: (convId, signal) => t.request("GET", tools(convId), { signal }),
+    replace: (convId, input) => t.request("PUT", tools(convId), { body: input }),
+    listCalls: (convId, signal) => t.request("GET", calls(convId), { signal }),
+    claim: (convId, toolCallId, input) => t.request("POST", `${calls(convId)}/${enc(toolCallId)}/claim`, {
+      body: input
+    }),
+    releaseClaim: (convId, toolCallId, claimant) => t.request("DELETE", `${calls(convId)}/${enc(toolCallId)}/claim`, {
+      query: { claimant },
+      raw: true
+    }),
+    submitResult: (convId, toolCallId, input) => t.request("POST", `${calls(convId)}/${enc(toolCallId)}/result`, {
+      body: input,
+      raw: true
+    })
+  };
+}
+
+// src/admin/component-libraries.ts
+function componentLibrariesApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/component-libraries`;
+  const library = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", library(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", library(currentSlug), {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", library(slug), { raw: true })
+  };
+}
+
+// src/admin/conversations.ts
+function conversationsAdminApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/conversations`;
+  const conv = (id) => `${base}/${enc(id)}`;
+  const sendImages = (id, images, caption) => {
+    const form = new FormData;
+    for (const [i, entry] of images.entries()) {
+      form.append("file", entry.image, entry.filename ?? `image-${i + 1}.png`);
+      form.append("label", entry.label ?? "");
+    }
+    if (caption)
+      form.append("caption", caption);
+    return t.request("POST", `${conv(id)}/user_message/image`, {
+      body: form
+    });
+  };
+  return {
+    list: (query = {}, signal) => t.request("GET", base, { query, signal }),
+    get: (id, signal) => t.request("GET", conv(id), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (id, input) => t.request("PATCH", conv(id), { body: input }),
+    archive: (id) => t.request("POST", `${conv(id)}/archive`),
+    retryNow: (id) => t.request("POST", `${conv(id)}/retry-now`),
+    listEvents: (id, query = {}, signal) => t.request("GET", `${conv(id)}/events`, { query, signal }),
+    sendUserMessage: (id, content) => t.request("POST", `${conv(id)}/user_message`, {
+      body: { content }
+    }),
+    sendUserAudio: (id, audio, filename = "recording.webm") => {
+      const form = new FormData;
+      form.append("audio", audio, filename);
+      return t.request("POST", `${conv(id)}/user_message/audio`, {
+        body: form
+      });
+    },
+    sendUserImage: (id, image, opts = {}) => sendImages(id, [{ image, filename: opts.filename, label: opts.label }], opts.caption),
+    sendUserImages: (id, images, opts = {}) => sendImages(id, images, opts.caption),
+    steer: (id, content) => t.request("POST", `${conv(id)}/steer`, {
+      body: { content }
+    }),
+    listSubConversations: (id, signal) => t.request("GET", `${conv(id)}/sub-conversations`, {
+      signal
+    }),
+    getSummary: (id, summaryId, signal) => t.request("GET", `${conv(id)}/summaries/${enc(summaryId)}`, { signal }),
+    listKnowledgeBases: (id, signal) => t.request("GET", `${conv(id)}/knowledge-bases`, {
+      signal
+    }),
+    attachKnowledgeBase: (id, kbSlug) => t.request("PUT", `${conv(id)}/knowledge-bases/${enc(kbSlug)}`, { raw: true }),
+    detachKnowledgeBase: (id, kbSlug) => t.request("DELETE", `${conv(id)}/knowledge-bases/${enc(kbSlug)}`, { raw: true }),
+    listSkills: (id, signal) => t.request("GET", `${conv(id)}/skills`, { signal }),
+    addSkill: (id, skillSlug) => t.request("PUT", `${conv(id)}/skills/${enc(skillSlug)}`, { raw: true }),
+    removeSkill: (id, skillSlug) => t.request("DELETE", `${conv(id)}/skills/${enc(skillSlug)}`, { raw: true }),
+    workspaceDir: (id, atSeq, path, signal) => t.request("GET", `${conv(id)}/workspace/dir`, {
+      query: { at_seq: atSeq, path },
+      signal
+    }),
+    workspaceFile: (id, query) => t.fetchRaw("GET", `${conv(id)}/workspace/file`, { query }),
+    workspaceWrite: (id, path, file, filename) => {
+      const form = new FormData;
+      form.append("file", file, filename ?? path.split("/").pop() ?? "upload");
+      return t.request("PUT", `${conv(id)}/workspace/file`, {
+        query: { path },
+        body: form
+      });
+    },
+    workspaceWriteMany: (id, files) => {
+      const form = new FormData;
+      for (const [i, entry] of files.entries()) {
+        form.append("file", entry.file, entry.filename ?? `file-${i + 1}`);
+        form.append("path", entry.path);
+      }
+      return t.request("POST", `${conv(id)}/workspace/files`, { body: form });
+    },
+    workspaceDelete: (id, path) => t.request("DELETE", `${conv(id)}/workspace/file`, {
+      query: { path }
+    }),
+    workspaceMove: (id, from, to) => t.request("POST", `${conv(id)}/workspace/move`, {
+      body: { from, to }
+    }),
+    eventAttachment: (id, eventId, attachmentId) => t.fetchRaw("GET", `${conv(id)}/events/${eventId}/attachment`, {
+      query: { attachment_id: attachmentId }
+    })
+  };
+}
+
+// src/admin/global.ts
+function tenantsApi(t) {
+  return {
+    list: (signal) => t.request("GET", "/api/v1/tenants", { signal }),
+    create: (input) => t.request("POST", "/api/v1/tenants", { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", `/api/v1/tenants/${enc(currentSlug)}`, {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", `/api/v1/tenants/${enc(slug)}`, { raw: true })
+  };
+}
+function apiKeysApi(t) {
+  const base = "/api/v1/api_keys";
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (id, signal) => t.request("GET", `${base}/${enc(id)}`, { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (id, input) => t.request("PATCH", `${base}/${enc(id)}`, { body: input }),
+    delete: (id) => t.request("DELETE", `${base}/${enc(id)}`, { raw: true }),
+    rotate: (id) => t.request("POST", `${base}/${enc(id)}/rotate`),
+    addGrant: (id, input) => t.request("POST", `${base}/${enc(id)}/grants`, { body: input }),
+    removeGrant: (id, grantId) => t.request("DELETE", `${base}/${enc(id)}/grants/${enc(grantId)}`, { raw: true })
+  };
+}
+function sharedProvidersApi(t) {
+  const base = "/api/v1/ai-providers/shared";
+  return {
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", `${base}/${enc(currentSlug)}`, {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", `${base}/${enc(slug)}`, { raw: true }),
+    refreshModels: (slug) => t.request("POST", `${base}/${enc(slug)}/models/refresh`),
+    updateModel: (slug, modelId, input) => t.request("PATCH", `${base}/${enc(slug)}/models/${enc(modelId)}`, {
+      body: input,
+      raw: true
+    })
+  };
+}
+
+// src/admin/knowledge-bases.ts
+function knowledgeBasesApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/knowledge-bases`;
+  const kb = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", kb(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", kb(currentSlug), {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", kb(slug), { raw: true }),
+    requestCuration: (slug) => t.request("POST", `${kb(slug)}/curate`, { raw: true }),
+    listSources: (slug, signal) => t.request("GET", `${kb(slug)}/sources`, { signal }),
+    createTextSource: (slug, input) => t.request("POST", `${kb(slug)}/sources/text`, {
+      body: input
+    }),
+    uploadSource: (slug, file, title) => {
+      const form = new FormData;
+      form.append("file", file);
+      if (title?.trim())
+        form.append("title", title.trim());
+      return t.request("POST", `${kb(slug)}/sources`, {
+        body: form
+      });
+    },
+    retractSource: (slug, sourceId) => t.request("DELETE", `${kb(slug)}/sources/${enc(sourceId)}`, { raw: true }),
+    downloadSource: (slug, sourceId) => t.fetchRaw("GET", `${kb(slug)}/sources/${enc(sourceId)}/content`),
+    listPages: (slug, signal) => t.request("GET", `${kb(slug)}/pages`, { signal }),
+    getPage: (slug, pageSlug, signal) => t.request("GET", `${kb(slug)}/pages/${enc(pageSlug)}`, {
+      signal
+    }),
+    updatePage: (slug, pageSlug, input) => t.request("PUT", `${kb(slug)}/pages/${enc(pageSlug)}`, {
+      body: input
+    })
+  };
+}
+
+// src/admin/mcps.ts
+function mcpsApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/mcps`;
+  const mcp = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", mcp(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", mcp(currentSlug), {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", mcp(slug), { raw: true }),
+    refresh: (slug) => t.request("POST", `${mcp(slug)}/refresh`),
+    updateTool: (slug, toolName, enabled) => t.request("PATCH", `${mcp(slug)}/tools/${enc(toolName)}`, {
+      body: { enabled }
+    }),
+    getSkill: (slug, skillSlug, signal) => t.request("GET", `${mcp(slug)}/skills/${enc(skillSlug)}`, { signal }),
+    createSkill: (slug, input) => t.request("POST", `${mcp(slug)}/skills`, { body: input }),
+    updateSkill: (slug, currentSkillSlug, input) => t.request("PATCH", `${mcp(slug)}/skills/${enc(currentSkillSlug)}`, {
+      body: withoutNoopRename(input, currentSkillSlug)
+    }),
+    deleteSkill: (slug, skillSlug) => t.request("DELETE", `${mcp(slug)}/skills/${enc(skillSlug)}`, { raw: true })
+  };
+}
+
+// src/admin/skills.ts
+function skillsApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/skills`;
+  const skill = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", skill(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", skill(currentSlug), {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", skill(slug), { raw: true })
+  };
+}
+
+// src/admin/task-templates.ts
+function taskTemplatesApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/task-templates`;
+  const template = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", template(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (currentSlug, input) => t.request("PATCH", template(currentSlug), {
+      body: withoutNoopRename(input, currentSlug)
+    }),
+    delete: (slug) => t.request("DELETE", template(slug), { raw: true }),
+    createSecret: (slug) => t.request("POST", `${template(slug)}/secret`),
+    revokeSecret: (slug) => t.request("DELETE", `${template(slug)}/secret`, { raw: true }),
+    trigger: (slug, input) => t.fetchRaw("POST", `${template(slug)}/trigger`, { body: input })
+  };
+}
+function scheduledRunsApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/scheduled-runs`;
+  return {
+    list: (query = {}, signal) => t.request("GET", base, { query, signal }),
+    get: (id, signal) => t.request("GET", `${base}/${enc(id)}`, { signal }),
+    update: (id, input) => t.request("PATCH", `${base}/${enc(id)}`, { body: input }),
+    cancel: (id) => t.request("DELETE", `${base}/${enc(id)}`, { raw: true })
+  };
+}
+function backgroundTasksApi(t, tenantSlug) {
+  return {
+    spawn: (input) => t.request("POST", `${tenantPath(tenantSlug)}/background-tasks`, { body: input })
+  };
+}
+
+// src/admin/users.ts
+function usersApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/users`;
+  const user = (id) => `${base}/${enc(id)}`;
+  return {
+    list: (query = {}, signal) => t.request("GET", base, { query, signal }),
+    get: (id, signal) => t.request("GET", user(id), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (id, input) => t.request("PATCH", user(id), { body: input }),
+    delete: (id) => t.request("DELETE", user(id), { raw: true }),
+    approve: (id, input) => t.request("POST", `${user(id)}/approve`, { body: input }),
+    block: (id) => t.request("POST", `${user(id)}/block`),
+    unblock: (id) => t.request("POST", `${user(id)}/unblock`),
+    merge: (id, input) => t.request("POST", `${user(id)}/merge`, { body: input }),
+    attachRole: (id, roleSlug) => t.request("PUT", `${user(id)}/roles/${enc(roleSlug)}`, { raw: true }),
+    detachRole: (id, roleSlug) => t.request("DELETE", `${user(id)}/roles/${enc(roleSlug)}`, { raw: true }),
+    addIdentity: (id, input) => t.request("POST", `${user(id)}/identities`, { body: input }),
+    deleteIdentity: (id, identityId) => t.request("DELETE", `${user(id)}/identities/${enc(identityId)}`, { raw: true }),
+    listKnowledgeBases: (id, signal) => t.request("GET", `${user(id)}/knowledge-bases`, {
+      signal
+    }),
+    attachKnowledgeBase: (id, kbSlug) => t.request("PUT", `${user(id)}/knowledge-bases/${enc(kbSlug)}`, { raw: true }),
+    detachKnowledgeBase: (id, kbSlug) => t.request("DELETE", `${user(id)}/knowledge-bases/${enc(kbSlug)}`, { raw: true }),
+    getMemory: (id, signal) => t.request("GET", `${user(id)}/memory`, { signal }),
+    listMemoryObservations: (id, signal) => t.request("GET", `${user(id)}/memory/observations`, {
+      signal
+    }),
+    createMemoryObservation: (id, input) => t.request("POST", `${user(id)}/memory/observations`, {
+      body: input
+    }),
+    deleteMemoryObservation: (id, observationId) => t.request("DELETE", `${user(id)}/memory/observations/${enc(observationId)}`, {
+      raw: true
+    }),
+    updateMemoryProfile: (id, input) => t.request("PATCH", `${user(id)}/memory/profile`, {
+      body: input
+    })
+  };
+}
+function userRolesApi(t, tenantSlug) {
+  const base = `${tenantPath(tenantSlug)}/user-roles`;
+  const role = (slug) => `${base}/${enc(slug)}`;
+  return {
+    list: (signal) => t.request("GET", base, { signal }),
+    get: (slug, signal) => t.request("GET", role(slug), { signal }),
+    create: (input) => t.request("POST", base, { body: input }),
+    update: (slug, input) => t.request("PATCH", role(slug), { body: input }),
+    delete: (slug) => t.request("DELETE", role(slug), { raw: true })
+  };
+}
+function userTokensApi(t, tenantSlug) {
+  return {
+    create: (input) => t.request("POST", `${tenantPath(tenantSlug)}/user-tokens`, {
+      body: input
+    })
+  };
+}
+
+// src/admin/index.ts
+function tenantScope(t, slug) {
+  return {
+    slug,
+    agents: agentsApi(t, slug),
+    aiProviders: aiProvidersApi(t, slug),
+    mcps: mcpsApi(t, slug),
+    skills: skillsApi(t, slug),
+    componentLibraries: componentLibrariesApi(t, slug),
+    channels: channelsApi(t, slug),
+    users: usersApi(t, slug),
+    userRoles: userRolesApi(t, slug),
+    userTokens: userTokensApi(t, slug),
+    knowledgeBases: knowledgeBasesApi(t, slug),
+    taskTemplates: taskTemplatesApi(t, slug),
+    scheduledRuns: scheduledRunsApi(t, slug),
+    backgroundTasks: backgroundTasksApi(t, slug),
+    conversations: conversationsAdminApi(t, slug),
+    clientTools: clientToolsApi(t, slug)
+  };
+}
+function createAdminClient(options) {
+  const t = createTransport(options.baseUrl, { apiKey: options.apiKey }, options.fetch, options.timeoutMs, options.maxRetries);
+  const scopes = new Map;
+  return {
+    raw: t,
+    health: (signal) => t.request("GET", "/api/v1/health", { signal }),
+    me: (signal) => t.request("GET", "/api/v1/me", { signal }),
+    tenants: tenantsApi(t),
+    apiKeys: apiKeysApi(t),
+    sharedProviders: sharedProvidersApi(t),
+    tenant(slug) {
+      let scope = scopes.get(slug);
+      if (!scope) {
+        scope = tenantScope(t, slug);
+        scopes.set(slug, scope);
+      }
+      return scope;
+    }
+  };
+}
+// src/cache.ts
+var CACHE_VERSION = 3;
+
+class MemoryConversationCache {
+  #entries = new Map;
+  #max;
+  constructor(options = {}) {
+    this.#max = Math.max(1, options.maxConversations ?? 20);
+  }
+  read(key) {
+    const entry = this.#entries.get(key);
+    if (entry === undefined)
+      return Promise.resolve(null);
+    this.#entries.delete(key);
+    this.#entries.set(key, entry);
+    return Promise.resolve(entry);
+  }
+  write(key, entry) {
+    this.#entries.delete(key);
+    this.#entries.set(key, entry);
+    while (this.#entries.size > this.#max) {
+      const oldest = this.#entries.keys().next();
+      if (oldest.done)
+        break;
+      this.#entries.delete(oldest.value);
+    }
+    return Promise.resolve();
+  }
+  clear(key) {
+    if (key === undefined)
+      this.#entries.clear();
+    else
+      this.#entries.delete(key);
+    return Promise.resolve();
+  }
+  get size() {
+    return this.#entries.size;
+  }
+}
+function trimCached(entry, limit) {
+  if (entry.messages.length <= limit)
+    return entry;
+  const messages = entry.messages.slice(entry.messages.length - limit);
+  const head = messages[0];
+  const oldestSeq = head ? head.seq : entry.oldestSeq;
+  return {
+    ...entry,
+    messages,
+    ...entry.toolActivity === undefined ? {} : {
+      toolActivity: entry.toolActivity.filter((a) => oldestSeq === null || a.seq >= oldestSeq)
+    },
+    ...entry.plans === undefined ? {} : { plans: entry.plans.filter((p) => oldestSeq === null || p.seq >= oldestSeq) },
+    oldestSeq,
+    hasOlder: true
+  };
+}
+// src/mapping.ts
+var TRANSCRIPTION = Symbol("cubos.transcription");
+var SOURCE_EVENT = Symbol("cubos.sourceEvent");
+function toConversation(w) {
+  return {
+    id: w.id,
+    title: w.title ?? w.generated_title ?? null,
+    titleIsGenerated: w.title === null && w.generated_title !== null,
+    agentSlug: w.agent?.slug ?? null,
+    lastActivityAt: w.last_activity_at,
+    archived: w.archived_at !== null,
+    isProcessing: w.is_processing,
+    hasPendingTurn: w.has_pending_turn,
+    createdAt: w.created_at,
+    updatedAt: w.updated_at
+  };
+}
+function toTurnStatus(w) {
+  return { isProcessing: w.is_processing, hasPendingTurn: w.has_pending_turn };
+}
+function toMessage(w) {
+  if (w.tentative || w.discarded_at !== null)
+    return null;
+  if (w.type === "media_transcription" && w.content !== null) {
+    const message = {
+      id: w.id,
+      role: "user",
+      content: w.content,
+      attachments: [],
+      seq: w.seq,
+      at: w.created_at
+    };
+    const hidden = message;
+    hidden[TRANSCRIPTION] = true;
+    hidden[SOURCE_EVENT] = sourceEventId(w.result);
+    return message;
+  }
+  const role = w.type === "user_message" ? "user" : w.type === "agent_message" ? "agent" : null;
+  if (role === null || w.content === null)
+    return null;
+  const attachments = toAttachments(w);
+  if (role === "user" && w.content === "" && attachments.length === 0)
+    return null;
+  return {
+    id: w.id,
+    role,
+    content: w.content,
+    attachments,
+    seq: w.seq,
+    at: w.created_at,
+    ...w.blocks === undefined ? {} : { blocks: w.blocks }
+  };
+}
+function toAttachments(w) {
+  const out = [];
+  for (const a of w.attachments ?? []) {
+    if (a.kind !== "image" && a.kind !== "audio")
+      continue;
+    out.push({
+      id: a.id,
+      kind: a.kind,
+      mimeType: a.mime_type,
+      bytes: a.bytes,
+      label: a.label
+    });
+  }
+  return out;
+}
+function hasAudio(message) {
+  return message.attachments.some((a) => a.kind === "audio");
+}
+function sourceEventId(result) {
+  const id = result?.source_event_id;
+  return typeof id === "string" ? id : null;
+}
+function mergeVoiceMessages(messages) {
+  const out = [];
+  const awaitingText = [];
+  const byId = new Map;
+  for (const message of messages) {
+    const hidden = message;
+    if (hidden[TRANSCRIPTION] !== true) {
+      const copy = { ...message };
+      byId.set(copy.id, copy);
+      if (hasAudio(copy) && copy.transcribed !== true) {
+        copy.transcribed = false;
+        awaitingText.push(copy);
+      }
+      out.push(copy);
+      continue;
+    }
+    const sourceId = hidden[SOURCE_EVENT];
+    const source = typeof sourceId === "string" ? byId.get(sourceId) : undefined;
+    if (source) {
+      if (hasAudio(source)) {
+        source.content = message.content;
+        source.transcribed = true;
+      }
+      continue;
+    }
+    const clip = awaitingText.shift();
+    if (clip) {
+      clip.content = message.content;
+      clip.transcribed = true;
+      continue;
+    }
+    out.push(message);
+  }
+  return out;
+}
+var TODO_STATUS = {
+  pending: "pending",
+  in_progress: "in_progress",
+  done: "completed",
+  cancelled: "completed"
+};
+function toTodos(w) {
+  if (w.type !== "todo_update" || w.tentative || w.discarded_at !== null)
+    return null;
+  if (w.content === null)
+    return null;
+  let payload;
+  try {
+    payload = JSON.parse(w.content);
+  } catch {
+    return null;
+  }
+  const raw = payload?.items;
+  if (!Array.isArray(raw))
+    return null;
+  const todos = [];
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const { text, status } = item;
+    if (typeof text !== "string")
+      continue;
+    todos.push({
+      title: text,
+      status: (typeof status === "string" ? TODO_STATUS[status] : undefined) ?? "pending"
+    });
+  }
+  return todos;
+}
+function toPlanSnapshot(w) {
+  const todos = toTodos(w);
+  return todos === null ? null : { todos, seq: w.seq };
+}
+function toTurnDone(w) {
+  if (w.type !== "turn_done" || w.tentative || w.discarded_at !== null)
+    return null;
+  return w.seq;
+}
+function toClientToolCall(w) {
+  if (w.type !== "client_tool_call" || w.tentative || w.discarded_at !== null)
+    return null;
+  if (!w.tool_call_id || !w.tool_name)
+    return null;
+  return { toolCallId: w.tool_call_id, toolName: w.tool_name };
+}
+function toToolActivity(w) {
+  if (w.discarded_at !== null)
+    return null;
+  if (!w.tool_call_id || !w.tool_name)
+    return null;
+  if (w.type === "client_tool_call") {
+    const args = toArguments(w.content);
+    return {
+      toolCallId: w.tool_call_id,
+      toolName: w.tool_name,
+      ...args === undefined ? {} : { arguments: args },
+      status: "running",
+      seq: w.seq,
+      at: w.created_at
+    };
+  }
+  if (w.type === "tool_result") {
+    const failed = typeof w.error === "string" && w.error !== "";
+    return {
+      toolCallId: w.tool_call_id,
+      toolName: w.tool_name,
+      status: failed ? "error" : "ok",
+      ...w.result === undefined || w.result === null ? {} : { result: w.result },
+      ...failed ? { error: w.error } : {},
+      ...typeof w.duration_ms === "number" ? { durationMs: w.duration_ms } : {},
+      seq: w.seq,
+      at: w.created_at
+    };
+  }
+  return null;
+}
+function toArguments(content) {
+  if (content === null || content === "")
+    return;
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return;
+    return parsed;
+  } catch {
+    return;
+  }
+}
+function toToolCallArguments(w) {
+  if (w.type !== "llm_call" || w.discarded_at !== null)
+    return [];
+  const messages = w.llm_call_data?.response?.messages;
+  if (!Array.isArray(messages))
+    return [];
+  const out = [];
+  for (const m of messages) {
+    if (m.type !== "tool_call" || typeof m.tool_call_id !== "string")
+      continue;
+    const args = m.arguments;
+    if (typeof args !== "object" || args === null || Array.isArray(args))
+      continue;
+    out.push({ toolCallId: m.tool_call_id, arguments: args });
+  }
+  return out;
+}
+function withToolArguments(activity, known) {
+  if (activity.arguments !== undefined)
+    return activity;
+  const args = known.get(activity.toolCallId);
+  return args === undefined ? activity : { ...activity, arguments: args };
+}
+function mergeToolActivities(activities) {
+  const byId = new Map;
+  for (const incoming of activities) {
+    const held = byId.get(incoming.toolCallId);
+    byId.set(incoming.toolCallId, held === undefined ? incoming : fold(held, incoming));
+  }
+  return [...byId.values()].sort((a, b) => a.seq - b.seq);
+}
+function fold(a, b) {
+  const withArgs = a.arguments !== undefined ? a : b;
+  const outcome = a.status !== "running" ? a : b.status !== "running" ? b : null;
+  const earliest = a.seq <= b.seq ? a : b;
+  return {
+    toolCallId: a.toolCallId,
+    toolName: a.toolName,
+    ...withArgs.arguments === undefined ? {} : { arguments: withArgs.arguments },
+    status: outcome?.status ?? "running",
+    ...outcome?.result === undefined ? {} : { result: outcome.result },
+    ...outcome?.error === undefined ? {} : { error: outcome.error },
+    ...outcome?.durationMs === undefined ? {} : { durationMs: outcome.durationMs },
+    seq: earliest.seq,
+    at: earliest.at
+  };
+}
+
+// src/client.ts
+var MAX_IMAGES_PER_MESSAGE = 10;
+
+class AgentClient {
+  #transport;
+  #cache;
+  #cacheLimit;
+  #tenant;
+  #identity = null;
+  constructor(options) {
+    const getToken = "getToken" in options ? options.getToken : () => options.token;
+    this.#transport = createTransport(options.baseUrl, { getToken }, options.fetch, options.timeoutMs, options.maxRetries);
+    this.#tenant = options.tenant;
+    this.#cache = options.cache === undefined ? new MemoryConversationCache : options.cache;
+    this.#cacheLimit = Math.max(1, options.cacheMessageLimit ?? 300);
+  }
+  me() {
+    this.#identity ??= this.#fetchIdentity();
+    return this.#identity;
+  }
+  refreshIdentity() {
+    this.#identity = this.#fetchIdentity();
+    return this.#identity;
+  }
+  async#fetchIdentity() {
+    const raw = await this.#transport.request("GET", "/api/v1/me");
+    if (raw.user_id === null) {
+      throw new AgentApiError("This token is an api_key, not an end-user token. Mint one with POST /api/v1/tenants/{slug}/user-tokens and keep the api_key on your server.", 403);
+    }
+    const tenantSlug = this.#tenant ?? raw.tenants[0]?.slug;
+    if (!tenantSlug) {
+      throw new AgentApiError("Token resolves to no tenant.", 403);
+    }
+    this.#tenant = tenantSlug;
+    return {
+      userId: raw.user_id,
+      displayName: raw.display_name,
+      tenantSlug,
+      agentSlugs: raw.agent_slugs
+    };
+  }
+  async#base() {
+    if (this.#tenant === undefined)
+      await this.me();
+    return `/api/v1/tenants/${encodeURIComponent(this.#tenant)}/conversations`;
+  }
+  async listConversations(opts = {}) {
+    const query = { origin: "interactive", limit: opts.limit, before: opts.before };
+    const rows = await this.#transport.request("GET", `${await this.#base()}`, {
+      query,
+      signal: opts.signal
+    });
+    const items = rows.map(toConversation);
+    const last = rows.at(-1);
+    const exhausted = opts.limit !== undefined && rows.length < opts.limit;
+    return {
+      items,
+      nextCursor: last && !exhausted ? `${last.last_activity_at}|${last.id}` : null
+    };
+  }
+  async* iterateConversations(opts = {}) {
+    const limit = opts.pageSize ?? 50;
+    let before;
+    for (;; ) {
+      const page = await this.listConversations({ limit, before, signal: opts.signal });
+      for (const conversation of page.items)
+        yield conversation;
+      if (page.nextCursor === null)
+        return;
+      before = page.nextCursor;
+    }
+  }
+  async* iterateMessages(id, opts = {}) {
+    const limit = opts.pageSize ?? 50;
+    let before;
+    for (;; ) {
+      const page = await this.#messagePage(id, { limit, before, signal: opts.signal });
+      for (let i = page.messages.length - 1;i >= 0; i--)
+        yield page.messages[i];
+      if (page.eventCount < limit || page.oldestSeq === null)
+        return;
+      before = page.oldestSeq;
+    }
+  }
+  async createConversation(opts = {}) {
+    let agentSlug = opts.agentSlug;
+    if (agentSlug === undefined) {
+      const { agentSlugs } = await this.me();
+      if (agentSlugs.length !== 1) {
+        throw new AgentApiError(agentSlugs.length === 0 ? "This token was minted without any agent, so it can't start a conversation." : `This token covers ${agentSlugs.length} agents — pass agentSlug to pick one.`, 400);
+      }
+      agentSlug = agentSlugs[0];
+    }
+    const row = await this.#transport.request("POST", await this.#base(), {
+      body: {
+        agent_slug: agentSlug,
+        title: opts.title,
+        metadata: opts.metadata,
+        ...opts.componentLibraries === undefined ? {} : { component_libraries: opts.componentLibraries }
+      },
+      signal: opts.signal
+    });
+    return toConversation(row);
+  }
+  async setComponentLibraries(id, libraries, signal) {
+    return await this.#transport.request("PUT", `${await this.#base()}/${id}/component-libraries`, { body: { libraries }, signal });
+  }
+  async setContext(id, context, signal) {
+    await this.#transport.request("PUT", `${await this.#base()}/${id}/context`, {
+      body: { context },
+      signal
+    });
+  }
+  async listComponentLibraries(id, signal) {
+    return await this.#transport.request("GET", `${await this.#base()}/${id}/component-libraries`, { signal });
+  }
+  async getConversation(id, signal) {
+    const row = await this.#transport.request("GET", `${await this.#base()}/${id}`, { signal });
+    return toConversation(row);
+  }
+  async renameConversation(id, title, signal) {
+    const row = await this.#transport.request("PATCH", `${await this.#base()}/${id}`, { body: { title }, signal });
+    return toConversation(row);
+  }
+  async archiveConversation(id, signal) {
+    const row = await this.#transport.request("POST", `${await this.#base()}/${id}/archive`, { signal });
+    return toConversation(row);
+  }
+  async#messagePage(id, opts) {
+    const rows = await this.#transport.request("GET", `${await this.#base()}/${id}/events`, { query: { before: opts.before, limit: opts.limit }, signal: opts.signal });
+    const messages = mergeVoiceMessages(rows.map(toMessage).filter((m) => m !== null));
+    const argsByCall = new Map;
+    for (const row of rows) {
+      for (const call of toToolCallArguments(row))
+        argsByCall.set(call.toolCallId, call.arguments);
+    }
+    const toolActivity = mergeToolActivities(rows.map(toToolActivity).filter((a) => a !== null)).map((a) => withToolArguments(a, argsByCall));
+    const plans = rows.map(toPlanSnapshot).filter((p) => p !== null);
+    const turnDones = rows.map(toTurnDone).filter((n) => n !== null);
+    const lastTurnDoneSeq = turnDones.length === 0 ? null : Math.max(...turnDones);
+    let oldestSeq = null;
+    let latestChangeSeq = null;
+    for (const row of rows) {
+      if (oldestSeq === null || row.seq < oldestSeq)
+        oldestSeq = row.seq;
+      if (latestChangeSeq === null || row.change_seq > latestChangeSeq) {
+        latestChangeSeq = row.change_seq;
+      }
+    }
+    return {
+      messages,
+      toolActivity,
+      plans,
+      lastTurnDoneSeq,
+      oldestSeq,
+      latestChangeSeq,
+      eventCount: rows.length,
+      events: rows
+    };
+  }
+  async listMessages(id, opts = {}) {
+    return (await this.#messagePage(id, opts)).messages;
+  }
+  async loadHistory(id, opts = {}) {
+    const key = await this.#cacheKey(id);
+    if (key !== null && this.#cache) {
+      try {
+        const entry = await this.#cache.read(key);
+        if (entry && entry.version === CACHE_VERSION && entry.messages.length > 0) {
+          return {
+            messages: entry.messages,
+            toolActivity: entry.toolActivity ?? [],
+            plans: entry.plans ?? [],
+            lastTurnDoneSeq: entry.lastTurnDoneSeq ?? null,
+            oldestSeq: entry.oldestSeq,
+            latestChangeSeq: entry.latestChangeSeq,
+            hasOlder: entry.hasOlder,
+            fromCache: true
+          };
+        }
+      } catch {}
+    }
+    const page = await this.listMessagesPage(id, {
+      limit: opts.pageSize,
+      signal: opts.signal
+    });
+    await this.saveHistory(id, page);
+    return { ...page, fromCache: false };
+  }
+  async saveHistory(id, state) {
+    if (!this.#cache || state.latestChangeSeq === null || state.messages.length === 0)
+      return;
+    const key = await this.#cacheKey(id);
+    if (key === null)
+      return;
+    const entry = trimCached({
+      version: CACHE_VERSION,
+      messages: state.messages,
+      ...state.toolActivity === undefined ? {} : { toolActivity: state.toolActivity },
+      ...state.plans === undefined ? {} : { plans: state.plans },
+      ...state.lastTurnDoneSeq === undefined ? {} : { lastTurnDoneSeq: state.lastTurnDoneSeq },
+      latestChangeSeq: state.latestChangeSeq,
+      oldestSeq: state.oldestSeq,
+      hasOlder: state.hasOlder
+    }, this.#cacheLimit);
+    try {
+      await this.#cache.write(key, entry);
+    } catch {}
+  }
+  async forgetHistory(id) {
+    if (!this.#cache)
+      return;
+    if (id === undefined) {
+      await this.#cache.clear();
+      return;
+    }
+    const key = await this.#cacheKey(id);
+    if (key !== null)
+      await this.#cache.clear(key);
+  }
+  async#cacheKey(id) {
+    if (!this.#cache)
+      return null;
+    try {
+      const identity = await this.me();
+      return `${identity.tenantSlug}\x00${identity.userId}\x00${id}`;
+    } catch {
+      return null;
+    }
+  }
+  async listEventsPage(id, opts = {}) {
+    const limit = opts.limit ?? 50;
+    const page = await this.#messagePage(id, { ...opts, limit });
+    return {
+      events: page.events,
+      oldestSeq: page.oldestSeq,
+      latestChangeSeq: page.latestChangeSeq,
+      hasOlder: page.eventCount === limit
+    };
+  }
+  async listMessagesPage(id, opts = {}) {
+    const limit = opts.limit ?? 50;
+    const page = await this.#messagePage(id, { ...opts, limit });
+    return {
+      messages: page.messages,
+      toolActivity: page.toolActivity,
+      plans: page.plans,
+      lastTurnDoneSeq: page.lastTurnDoneSeq,
+      oldestSeq: page.oldestSeq,
+      latestChangeSeq: page.latestChangeSeq,
+      hasOlder: page.eventCount >= limit
+    };
+  }
+  async sendMessage(id, content, signal) {
+    await this.#transport.request("POST", `${await this.#base()}/${id}/user_message`, {
+      body: { content },
+      signal
+    });
+  }
+  async sendImage(id, image, opts = {}) {
+    await this.sendImages(id, [{ image, filename: opts.filename, label: opts.label }], {
+      caption: opts.caption,
+      signal: opts.signal
+    });
+  }
+  async sendImages(id, images, opts = {}) {
+    if (images.length === 0) {
+      throw new AgentApiError("sendImages needs at least one image.", 400);
+    }
+    if (images.length > MAX_IMAGES_PER_MESSAGE) {
+      throw new AgentApiError(`A message carries at most ${MAX_IMAGES_PER_MESSAGE} images (got ${images.length}).`, 400);
+    }
+    const form = new FormData;
+    for (const [i, entry] of images.entries()) {
+      form.append("file", entry.image, entry.filename ?? `image-${i + 1}.png`);
+      form.append("label", entry.label ?? "");
+    }
+    if (opts.caption)
+      form.append("caption", opts.caption);
+    await this.#transport.request("POST", `${await this.#base()}/${id}/user_message/image`, { body: form, signal: opts.signal });
+  }
+  async sendAudio(id, audio, opts = {}) {
+    const form = new FormData;
+    form.append("audio", audio, opts.filename ?? "recording.webm");
+    await this.#transport.request("POST", `${await this.#base()}/${id}/user_message/audio`, { body: form, signal: opts.signal });
+  }
+  async fetchAttachment(conversationId, messageId, attachmentId, signal) {
+    const res = await this.#transport.fetchRaw("GET", `${await this.#base()}/${conversationId}/events/${messageId}/attachment`, { query: { attachment_id: attachmentId }, signal });
+    await raiseForStatus(res, "Could not fetch the attachment.");
+    return await res.blob();
+  }
+  async listFiles(id, opts = {}) {
+    const raw = await this.#transport.request("GET", `${await this.#base()}/${id}/workspace/dir`, {
+      query: { path: opts.path, at_seq: opts.atSeq },
+      signal: opts.signal
+    });
+    return {
+      path: raw.path,
+      rootEventId: raw.root_event_id,
+      rootSeq: raw.root_seq,
+      entries: raw.entries.map((e) => ({
+        name: e.name,
+        kind: e.kind,
+        size: e.size,
+        mime: e.mime,
+        sha256: e.sha256,
+        exec: e.exec,
+        symlinkTarget: e.symlink_target
+      }))
+    };
+  }
+  async readFile(id, path, opts = {}) {
+    const res = await this.#transport.fetchRaw("GET", `${await this.#base()}/${id}/workspace/file`, { query: { path, at_seq: opts.atSeq }, signal: opts.signal });
+    await raiseForStatus(res, "Could not read the file.");
+    return await res.blob();
+  }
+  async writeFile(id, path, file, opts = {}) {
+    const form = new FormData;
+    form.append("file", file, opts.filename ?? path.split("/").pop() ?? "upload");
+    await this.#transport.request("PUT", `${await this.#base()}/${id}/workspace/file`, {
+      query: { path },
+      body: form,
+      signal: opts.signal
+    });
+  }
+  async writeFiles(id, files, opts = {}) {
+    if (files.length === 0) {
+      throw new AgentApiError("writeFiles needs at least one file.", 400);
+    }
+    const form = new FormData;
+    for (const [i, entry] of files.entries()) {
+      form.append("file", entry.file, entry.filename ?? `file-${i + 1}`);
+      form.append("path", entry.path);
+    }
+    await this.#transport.request("POST", `${await this.#base()}/${id}/workspace/files`, {
+      body: form,
+      signal: opts.signal
+    });
+  }
+  async deleteFile(id, path, signal) {
+    await this.#transport.request("DELETE", `${await this.#base()}/${id}/workspace/file`, {
+      query: { path },
+      signal
+    });
+  }
+  async moveFile(id, from, to, signal) {
+    await this.#transport.request("POST", `${await this.#base()}/${id}/workspace/move`, {
+      body: { from, to },
+      signal
+    });
+  }
+  async setClientTools(id, tools, signal) {
+    await this.#transport.request("PUT", `${await this.#base()}/${id}/client-tools`, {
+      body: { tools: declarations(tools) },
+      signal
+    });
+  }
+  serveClientTools(id, options) {
+    return serveClientTools(this.#transport, async () => `${await this.#base()}/${encodeURIComponent(id)}`, id, options);
+  }
+  async steer(id, content, signal) {
+    await this.#transport.request("POST", `${await this.#base()}/${id}/steer`, {
+      body: { content },
+      signal
+    });
+  }
+  subscribe(id, handlers, opts = {}) {
+    const controller = new AbortController;
+    const streamedArgs = new Map;
+    this.#base().then((base) => {
+      if (controller.signal.aborted)
+        return;
+      if (handlers.onMessage || handlers.onEvent || handlers.onTodos || handlers.onClientToolCall || handlers.onToolActivity || handlers.onTurnDone || handlers.onActivity || handlers.onOpen) {
+        readSse({
+          url: this.#transport.url(`${base}/${id}/events/stream`),
+          event: ["conversation_event", "conversation_status"],
+          lastEventId: opts.since === undefined ? undefined : String(opts.since),
+          headers: () => this.#transport.streamHeaders(),
+          fetchImpl: this.#transport.fetchImpl,
+          signal: controller.signal,
+          onError: handlers.onError,
+          onOpen: handlers.onOpen,
+          onEvent: (frame, name) => {
+            if (name === "conversation_status") {
+              handlers.onActivity?.(toTurnStatus(frame));
+              return;
+            }
+            const raw = frame;
+            handlers.onEvent?.(raw);
+            const message = toMessage(raw);
+            if (message)
+              handlers.onMessage?.(message);
+            const todos = toTodos(raw);
+            if (todos)
+              handlers.onTodos?.(todos, raw.seq);
+            const turnDone = toTurnDone(raw);
+            if (turnDone !== null)
+              handlers.onTurnDone?.(turnDone);
+            const call = toClientToolCall(raw);
+            if (call)
+              handlers.onClientToolCall?.(call);
+            for (const call2 of toToolCallArguments(raw)) {
+              streamedArgs.set(call2.toolCallId, call2.arguments);
+            }
+            const activity = toToolActivity(raw);
+            if (activity)
+              handlers.onToolActivity?.(withToolArguments(activity, streamedArgs));
+            handlers.onCursor?.(raw.change_seq);
+          }
+        }).catch((err) => handlers.onError?.(err));
+      }
+      if (handlers.onConversation) {
+        readSse({
+          url: this.#transport.url(`${base}/${id}/meta/stream`),
+          event: "conversation_meta",
+          headers: () => this.#transport.streamHeaders(),
+          fetchImpl: this.#transport.fetchImpl,
+          signal: controller.signal,
+          onError: handlers.onError,
+          onEvent: (raw) => handlers.onConversation?.(toConversation(raw))
+        }).catch((err) => handlers.onError?.(err));
+      }
+    });
+    return { close: () => controller.abort() };
+  }
+  subscribeToConversations(handlers) {
+    const controller = new AbortController;
+    this.#base().then((base) => {
+      if (controller.signal.aborted)
+        return;
+      readSse({
+        url: this.#transport.url(`${base}/stream`, { origin: "interactive" }),
+        event: "conversation",
+        headers: () => this.#transport.streamHeaders(),
+        fetchImpl: this.#transport.fetchImpl,
+        signal: controller.signal,
+        onError: handlers.onError,
+        onEvent: (raw) => handlers.onConversation(toConversation(raw))
+      }).catch((err) => handlers.onError?.(err));
+    });
+    return { close: () => controller.abort() };
+  }
+}
+function createUserClient(options) {
+  return new AgentClient(options);
+}
+export {
+  serveClientTools,
+  readSse,
+  mergeVoiceMessages,
+  mergeToolActivities,
+  createUserClient,
+  createAdminClient,
+  MemoryConversationCache,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_MAX_RETRIES,
+  AgentNetworkError,
+  AgentError,
+  AgentConfigError,
+  AgentClient,
+  AgentApiError
+};
+
+//# debugId=135CEC176CA70F7564756E2164756E21
+//# sourceMappingURL=index.js.map