@openhex-ai/agent-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,987 @@
+// src/errors.ts
+var OpenhexSdkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenhexSdkError";
+  }
+};
+var AuthenticationError = class extends OpenhexSdkError {
+  constructor(message = "No Openhex API key provided. Set OPENHEX_API_KEY or pass { apiKey }.") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var ApiError = class extends OpenhexSdkError {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+var AbortError = class extends OpenhexSdkError {
+  constructor(message = "The agent run was aborted.") {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+var NotImplementedError = class extends OpenhexSdkError {
+  constructor(what) {
+    super(`Not implemented yet: ${what}. This is a scaffold \u2014 runtime lands in a follow-up MR.`);
+    this.name = "NotImplementedError";
+  }
+};
+
+// src/transport.ts
+var HttpTransport = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  // eslint-disable-next-line require-yield
+  async *run(_request) {
+    throw new NotImplementedError("HttpTransport.run");
+  }
+};
+var DEFAULT_BASE_URL = "https://api.openhex.tech";
+
+// src/query.ts
+function resolveApiKey(options) {
+  const key = options.apiKey ?? process.env.OPENHEX_API_KEY;
+  if (!key) throw new AuthenticationError();
+  return key;
+}
+function query(params) {
+  const options = params.options ?? {};
+  const apiKey = resolveApiKey(options);
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const transport = new HttpTransport({ apiKey, baseUrl });
+  const prompt = typeof params.prompt === "string" ? params.prompt : "<streaming-input>";
+  const stream = transport.run({ prompt, options });
+  const q = stream;
+  q.interrupt = async () => {
+    await stream.return?.();
+  };
+  return q;
+}
+
+// src/http/httpClient.ts
+var API_PREFIX = "/api/v2";
+function resolveApiKey2(apiKey) {
+  const key = apiKey ?? (typeof process !== "undefined" ? process.env?.OPENHEX_API_KEY : void 0);
+  if (!key) throw new AuthenticationError();
+  return key;
+}
+function withTimeout(signal, timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return { signal: signal ?? new AbortController().signal, cancel: () => {
+    } };
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(signal?.reason);
+  if (signal) {
+    if (signal.aborted) controller.abort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  const timer = setTimeout(() => controller.abort(new Error(`Request timed out after ${timeoutMs}ms`)), timeoutMs);
+  return {
+    signal: controller.signal,
+    cancel: () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  loginType;
+  actAs;
+  extraHeaders;
+  timeoutMs;
+  fetchImpl;
+  constructor(config = {}) {
+    this.apiKey = resolveApiKey2(config.apiKey);
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.loginType = config.loginType;
+    this.actAs = config.actAs;
+    this.extraHeaders = config.headers ?? {};
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    const f = config.fetch ?? (typeof fetch !== "undefined" ? fetch : void 0);
+    if (!f) {
+      throw new Error("No fetch implementation available. Pass { fetch } in the client config.");
+    }
+    this.fetchImpl = f.bind(globalThis);
+  }
+  /** Build the full URL for an API path (prefixing `/api/v2` if needed). */
+  url(path) {
+    if (/^https?:\/\//.test(path)) return path;
+    const p = path.startsWith("/") ? path : `/${path}`;
+    const withPrefix = p.startsWith(API_PREFIX) ? p : `${API_PREFIX}${p}`;
+    return `${this.baseUrl}${withPrefix}`;
+  }
+  /** Headers common to every request. `accept` differs for SSE vs JSON. */
+  buildHeaders(accept, extra) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: accept,
+      ...this.extraHeaders,
+      ...extra
+    };
+    if (this.loginType) headers["X-Login-Type"] = this.loginType;
+    if (this.actAs) headers["X-Act-As"] = this.actAs;
+    return headers;
+  }
+  /** Map a non-2xx response to an {@link ApiError}, extracting `detail`. */
+  async toError(response) {
+    let body;
+    let detail;
+    try {
+      body = await response.json();
+      detail = body?.detail;
+    } catch {
+      try {
+        detail = await response.text();
+      } catch {
+      }
+    }
+    if (response.status === 401 || response.status === 403) {
+      return new ApiError(detail || "Unauthorized", response.status, body);
+    }
+    return new ApiError(detail || `Request failed with status ${response.status}`, response.status, body);
+  }
+  /** Perform a JSON request and parse the response body. */
+  async requestJson(path, options = {}) {
+    const response = await this.requestRaw(path, options, "application/json");
+    if (response.status === 204) return void 0;
+    return await response.json();
+  }
+  /** Perform a request and return the raw {@link Response} (used for SSE). */
+  async requestRaw(path, options = {}, accept = "application/json") {
+    const { method = "GET", body, headers, signal } = options;
+    const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+    const { signal: combined, cancel } = withTimeout(signal, timeoutMs);
+    const reqHeaders = this.buildHeaders(accept, headers);
+    if (body !== void 0) reqHeaders["Content-Type"] = "application/json";
+    let response;
+    try {
+      response = await this.fetchImpl(this.url(path), {
+        method,
+        headers: reqHeaders,
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: combined
+      });
+    } finally {
+      if (accept !== "text/event-stream") cancel();
+    }
+    if (!response.ok) {
+      if (accept !== "text/event-stream") cancel();
+      throw await this.toError(response);
+    }
+    return response;
+  }
+};
+
+// src/http/sse.ts
+function fieldValue(raw) {
+  return raw.startsWith(" ") ? raw.slice(1) : raw;
+}
+async function* parseSSEStream(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let dataLines = [];
+  let eventType;
+  let lastId;
+  const onAbort = () => {
+    reader.cancel().catch(() => {
+    });
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nlIndex;
+      while ((nlIndex = buffer.indexOf("\n")) !== -1) {
+        let line = buffer.slice(0, nlIndex);
+        buffer = buffer.slice(nlIndex + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        if (line === "") {
+          if (dataLines.length > 0) {
+            yield { id: lastId, event: eventType, data: dataLines.join("\n") };
+          }
+          dataLines = [];
+          eventType = void 0;
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        const rawVal = colon === -1 ? "" : line.slice(colon + 1);
+        const val = fieldValue(rawVal);
+        switch (field) {
+          case "data":
+            dataLines.push(val);
+            break;
+          case "id":
+            lastId = val;
+            break;
+          case "event":
+            eventType = val;
+            break;
+        }
+      }
+    }
+    if (dataLines.length > 0) {
+      yield { id: lastId, event: eventType, data: dataLines.join("\n") };
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    reader.releaseLock();
+  }
+}
+
+// src/http/backoff.ts
+var Backoff = class {
+  attempt = 0;
+  initialMs;
+  maxMs;
+  factor;
+  constructor(opts = {}) {
+    this.initialMs = opts.initialMs ?? 1e3;
+    this.maxMs = opts.maxMs ?? 15e3;
+    this.factor = opts.factor ?? 2;
+  }
+  /** Next delay in ms (advances the attempt counter). */
+  next() {
+    const delay2 = Math.min(this.maxMs, this.initialMs * Math.pow(this.factor, this.attempt));
+    this.attempt += 1;
+    return delay2;
+  }
+  /** Reset after a successful connection. */
+  reset() {
+    this.attempt = 0;
+  }
+};
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new DOMException("Aborted", "AbortError"));
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/chat/events.ts
+function isAgentRecord(record) {
+  return record.sender === "assistant" || record.sender === "agent";
+}
+function isTurnComplete(record) {
+  return isAgentRecord(record) && record.raw?.type === "result";
+}
+function isInterrupt(record) {
+  return record.sender === "system" && record.raw?.subtype === "interrupt";
+}
+function contentBlocks(record) {
+  const msg = record.raw.message;
+  if (msg && typeof msg === "object" && Array.isArray(msg.content)) {
+    return msg.content;
+  }
+  return [];
+}
+function extractText(record) {
+  if (record.raw?.type === "user" && typeof record.raw.message === "string") {
+    return record.raw.message;
+  }
+  return contentBlocks(record).filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+function extractToolCalls(record) {
+  return contentBlocks(record).filter((b) => b.type === "tool_use").map((b) => ({ id: b.id, name: b.name, input: b.input }));
+}
+
+// src/chat/chatClient.ts
+function anySignal(signals) {
+  const controller = new AbortController();
+  const handlers = [];
+  for (const s of signals) {
+    if (!s) continue;
+    if (s.aborted) {
+      controller.abort(s.reason);
+      break;
+    }
+    const handler = () => controller.abort(s.reason);
+    s.addEventListener("abort", handler, { once: true });
+    handlers.push([s, handler]);
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => handlers.forEach(([s, h]) => s.removeEventListener("abort", h))
+  };
+}
+function parseRecord(evt) {
+  if (evt.data === "[DONE]") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(evt.data);
+  } catch {
+    return null;
+  }
+  if (parsed._meta === true) return null;
+  const record = parsed;
+  if (evt.id) record.id = evt.id;
+  return record;
+}
+var AgentChatClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create or continue a conversation and route a message to its agent(s).
+   * Returns immediately (non-blocking); consume {@link stream} for the reply.
+   */
+  async send(req, opts = {}) {
+    return this.http.requestJson("/conversations/send", {
+      method: "POST",
+      body: req,
+      signal: opts.signal
+    });
+  }
+  /** Interrupt the conversation's currently-running turn. */
+  async interrupt(conversationId, opts = {}) {
+    return this.http.requestJson(`/conversations/${conversationId}/interrupt`, {
+      method: "POST",
+      signal: opts.signal
+    });
+  }
+  /** Full conversation history (all messages as JSON). */
+  async messages(conversationId, opts = {}) {
+    return this.http.requestJson(`/conversations/${conversationId}/messages`, { signal: opts.signal });
+  }
+  /** A page of older history, before a cursor. */
+  async history(conversationId, params, opts = {}) {
+    const q = new URLSearchParams({ before: params.before });
+    if (params.turns != null) q.set("turns", String(params.turns));
+    if (params.maxEntries != null) q.set("maxEntries", String(params.maxEntries));
+    return this.http.requestJson(`/conversations/${conversationId}/history?${q.toString()}`, {
+      signal: opts.signal
+    });
+  }
+  /**
+   * Open the conversation's SSE record stream. Yields every record
+   * (replayed history then live tail), auto-reconnecting with capped
+   * backoff on drop. The generator ends when the consumer breaks/returns
+   * or `signal` aborts.
+   */
+  async *stream(conversationId, opts = {}) {
+    const { signal, reconnect = true } = opts;
+    let cursor = opts.lastEventId;
+    const backoff = new Backoff();
+    const internal = new AbortController();
+    const onAbort = () => internal.abort();
+    if (signal) {
+      if (signal.aborted) internal.abort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const buildPath = () => {
+      const q = new URLSearchParams();
+      if (cursor) q.set("lastEventId", cursor);
+      if (opts.turns != null) q.set("turns", String(opts.turns));
+      if (opts.maxEntries != null) q.set("maxEntries", String(opts.maxEntries));
+      const qs = q.toString();
+      return `/conversations/${conversationId}/stream${qs ? `?${qs}` : ""}`;
+    };
+    try {
+      while (!internal.signal.aborted) {
+        let body = null;
+        try {
+          const response = await this.http.requestRaw(
+            buildPath(),
+            { signal: internal.signal, timeoutMs: 0 },
+            "text/event-stream"
+          );
+          body = response.body;
+          backoff.reset();
+        } catch (err) {
+          if (internal.signal.aborted) return;
+          if (!reconnect) throw err;
+          await delay(backoff.next(), internal.signal);
+          continue;
+        }
+        if (body) {
+          try {
+            for await (const evt of parseSSEStream(body, internal.signal)) {
+              if (evt.data === "[DONE]") return;
+              const record = parseRecord(evt);
+              if (!record) continue;
+              cursor = record.id ?? evt.id ?? cursor;
+              yield record;
+            }
+          } catch (err) {
+            if (internal.signal.aborted) return;
+            if (!reconnect) throw err;
+          }
+        }
+        if (!reconnect || internal.signal.aborted) return;
+        await delay(backoff.next(), internal.signal);
+      }
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      internal.abort();
+    }
+  }
+  /**
+   * Stream a single turn over an existing conversation: resume the event
+   * stream strictly after `opts.lastEventId` (the user message's event id)
+   * and stop at the agent's terminal `result`. Reconnects on drop; an
+   * `idleTimeoutMs` gap with no events aborts (covers cold-start pod
+   * provisioning). Use when you sent the message yourself via {@link send}.
+   */
+  async *resumeTurn(conversationId, opts = {}) {
+    const { signal, idleTimeoutMs = 18e4 } = opts;
+    const cursor = opts.lastEventId;
+    const idleController = new AbortController();
+    const merged = anySignal([signal, idleController.signal]);
+    let idleTimer;
+    const armIdle = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => idleController.abort(new Error("idle timeout")), idleTimeoutMs);
+    };
+    armIdle();
+    try {
+      for await (const record of this.stream(conversationId, {
+        lastEventId: cursor,
+        signal: merged.signal
+      })) {
+        armIdle();
+        yield record;
+        if (isTurnComplete(record)) return;
+      }
+      if (idleController.signal.aborted && !signal?.aborted) {
+        throw new AbortError("Turn timed out waiting for the agent to respond.");
+      }
+    } finally {
+      if (idleTimer) clearTimeout(idleTimer);
+      merged.cleanup();
+      idleController.abort();
+    }
+  }
+  /**
+   * Send a message and stream just this turn's records, ending when the
+   * agent's `result` event arrives.
+   *
+   * The message is sent first; the stream then resumes precisely from the
+   * user message's event id, so only the agent's reply is surfaced — no
+   * history, no heuristics. To learn the (possibly new) conversation id
+   * while streaming, use {@link sendMessage} or the stateful
+   * {@link Conversation}.
+   *
+   * The first message in a new conversation auto-provisions the agent's
+   * pod, so the first turn can take tens of seconds before any record
+   * arrives; `idleTimeoutMs` (default 180s) bounds the wait.
+   */
+  async *runTurn(req, opts = {}) {
+    const result = await this.send(req, { signal: opts.signal });
+    yield* this.resumeTurn(result.conversationId, { ...opts, lastEventId: result.userEventId });
+  }
+  /**
+   * Send a message and resolve with the aggregated turn (assistant text,
+   * tool calls, all records, conversation id, and a resume cursor).
+   */
+  async sendMessage(req, opts = {}) {
+    const result = await this.send(req, { signal: opts.signal });
+    const turn = {
+      conversationId: result.conversationId,
+      text: "",
+      toolCalls: [],
+      records: [],
+      sessionId: null
+    };
+    for await (const record of this.resumeTurn(result.conversationId, {
+      ...opts,
+      lastEventId: result.userEventId
+    })) {
+      turn.records.push(record);
+      if (record.id) turn.lastEventId = record.id;
+      if (record.sessionId) turn.sessionId = record.sessionId;
+      if (record.sender === "assistant" || record.sender === "agent") {
+        turn.text += extractText(record);
+        turn.toolCalls.push(...extractToolCalls(record));
+      }
+      if (isTurnComplete(record)) turn.result = record.raw;
+    }
+    return turn;
+  }
+  /**
+   * Start a stateful conversation handle that remembers its id across
+   * turns. The first {@link Conversation.send} creates the conversation
+   * (routed to `targetAgentIds`); subsequent sends continue it.
+   */
+  conversation(opts = {}) {
+    return new Conversation(this, opts.conversationId, opts.targetAgentIds);
+  }
+};
+var Conversation = class {
+  constructor(client, conversationId, targetAgentIds) {
+    this.client = client;
+    this.conversationId = conversationId;
+    this.targetAgentIds = targetAgentIds;
+  }
+  /** The conversation id, once the first message has been sent. */
+  get id() {
+    return this.conversationId;
+  }
+  /** Build the send request for the next turn (create vs continue). */
+  buildRequest(message, extra) {
+    return this.conversationId ? { message, conversationId: this.conversationId, ...extra } : { message, targetAgentIds: this.targetAgentIds, ...extra };
+  }
+  /** Send a turn and resolve with the aggregated result. */
+  async send(message, opts = {}) {
+    const turn = await this.client.sendMessage(this.buildRequest(message, opts), opts);
+    this.conversationId = turn.conversationId;
+    return turn;
+  }
+  /** Send a turn and stream its records as they arrive. */
+  async *stream(message, opts = {}) {
+    const sent = await this.client.send(this.buildRequest(message, opts), { signal: opts.signal });
+    this.conversationId = sent.conversationId;
+    yield* this.client.resumeTurn(sent.conversationId, {
+      ...opts,
+      lastEventId: sent.userEventId
+    });
+  }
+  /** Interrupt the running turn in this conversation. */
+  async interrupt() {
+    if (!this.conversationId) return { ok: true, interrupted: false, reason: "No conversation yet" };
+    return this.client.interrupt(this.conversationId);
+  }
+};
+
+// src/chat/trainingChatClient.ts
+function parseRecord2(evt) {
+  if (evt.data === "[DONE]") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(evt.data);
+  } catch {
+    return null;
+  }
+  if (parsed._meta === true) return null;
+  const record = parsed;
+  if (evt.id) record.id = evt.id;
+  return record;
+}
+var TrainingChat = class {
+  constructor(http, agentId) {
+    this.http = http;
+    this.agentId = agentId;
+  }
+  /** Send a training message; the reply streams asynchronously (see {@link stream}). */
+  async send(message, opts = {}) {
+    return this.http.requestJson(
+      `/agents/${this.agentId}/dev/send`,
+      { method: "POST", body: { message }, signal: opts.signal }
+    );
+  }
+  /** Interrupt the running training turn. */
+  async interrupt(opts = {}) {
+    return this.http.requestJson(
+      `/agents/${this.agentId}/dev/interrupt`,
+      { method: "POST", signal: opts.signal }
+    );
+  }
+  /**
+   * Training transcript (JSON), paginated backward from `before` (a Redis
+   * stream id). The endpoint REQUIRES `before`, so we default to a
+   * far-future sentinel to fetch the latest turns; pass a real id to page
+   * older history.
+   */
+  async messages(opts = {}) {
+    const before = opts.before ?? "99999999999999-0";
+    return this.http.requestJson(
+      `/agents/${this.agentId}/messages/history?before=${encodeURIComponent(before)}`,
+      { signal: opts.signal }
+    );
+  }
+  /** Raw SSE record stream of the training thread (replayed + live tail). */
+  async *stream(opts = {}) {
+    const { signal, reconnect = true } = opts;
+    let cursor = opts.lastEventId;
+    const backoff = new Backoff();
+    const internal = new AbortController();
+    const onAbort = () => internal.abort();
+    if (signal) {
+      if (signal.aborted) internal.abort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const buildPath = () => {
+      const q = new URLSearchParams();
+      if (cursor) q.set("lastEventId", cursor);
+      if (opts.turns != null) q.set("turns", String(opts.turns));
+      const qs = q.toString();
+      return `/agents/${this.agentId}/messages/stream${qs ? `?${qs}` : ""}`;
+    };
+    try {
+      while (!internal.signal.aborted) {
+        let body = null;
+        try {
+          const response = await this.http.requestRaw(
+            buildPath(),
+            { signal: internal.signal, timeoutMs: 0 },
+            "text/event-stream"
+          );
+          body = response.body;
+          backoff.reset();
+        } catch (err) {
+          if (internal.signal.aborted) return;
+          if (!reconnect) throw err;
+          await delay(backoff.next(), internal.signal);
+          continue;
+        }
+        if (body) {
+          try {
+            for await (const evt of parseSSEStream(body, internal.signal)) {
+              if (evt.data === "[DONE]") return;
+              const record = parseRecord2(evt);
+              if (!record) continue;
+              cursor = record.id ?? evt.id ?? cursor;
+              yield record;
+            }
+          } catch (err) {
+            if (internal.signal.aborted) return;
+            if (!reconnect) throw err;
+          }
+        }
+        if (!reconnect || internal.signal.aborted) return;
+        await delay(backoff.next(), internal.signal);
+      }
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      internal.abort();
+    }
+  }
+  /**
+   * Send a training message and stream just that turn's records, ending at
+   * the agent's terminal `result`. Streams the latest turn (`turns=1`) after
+   * the send; an `idleTimeoutMs` gap (default 180s) bounds cold-start waits.
+   */
+  async *runTurn(message, opts = {}) {
+    await this.send(message, { signal: opts.signal });
+    const { signal, idleTimeoutMs = 18e4 } = opts;
+    const idleController = new AbortController();
+    let idleTimer;
+    const combined = new AbortController();
+    const onA = () => combined.abort();
+    const onIdle = () => combined.abort();
+    signal?.addEventListener("abort", onA, { once: true });
+    idleController.signal.addEventListener("abort", onIdle, { once: true });
+    const armIdle = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => idleController.abort(new Error("idle timeout")), idleTimeoutMs);
+    };
+    armIdle();
+    try {
+      for await (const record of this.stream({ turns: 1, signal: combined.signal })) {
+        armIdle();
+        yield record;
+        if (isTurnComplete(record)) return;
+      }
+      if (idleController.signal.aborted && !signal?.aborted) {
+        throw new AbortError("Training turn timed out waiting for the agent.");
+      }
+    } finally {
+      if (idleTimer) clearTimeout(idleTimer);
+      signal?.removeEventListener("abort", onA);
+      combined.abort();
+    }
+  }
+};
+
+// src/workspace/workspaceClient.ts
+var seg = (s) => encodeURIComponent(s);
+var WorkspaceClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // -- Partner (workspace API key) -----------------------------------------
+  /**
+   * Identify the workspace the configured API key belongs to. Solves the
+   * bootstrap problem for a new partner who holds only the `sk_ws_…` token
+   * but every slug-keyed route needs a slug.
+   */
+  whoami(opts = {}) {
+    return this.http.requestJson("/workspaces/whoami", { signal: opts.signal });
+  }
+  /**
+   * Provision (or look up) a workspace member by SP user reference.
+   * Idempotent on `(workspace, sp_user_ref)` — the first call creates the
+   * member, later calls return the existing ids (`created: false`).
+   */
+  provisionMember(slug, body, opts = {}) {
+    return this.http.requestJson(`/workspaces/${seg(slug)}/members`, {
+      method: "POST",
+      body,
+      signal: opts.signal
+    });
+  }
+  /** Suspend a member (soft — sets status to `suspended`). */
+  async suspendMember(slug, memberId, opts = {}) {
+    await this.http.requestJson(`/workspaces/${seg(slug)}/members/${seg(memberId)}`, {
+      method: "DELETE",
+      signal: opts.signal
+    });
+  }
+  /**
+   * Mint a session JWT for an already-provisioned member. The partner
+   * authenticates the human on their side, then calls this with the same
+   * `sp_user_ref` to get a token the member's client presents to the platform.
+   */
+  mintSession(slug, body, opts = {}) {
+    return this.http.requestJson(`/workspaces/${seg(slug)}/sessions`, {
+      method: "POST",
+      body,
+      signal: opts.signal
+    });
+  }
+  // -- Either auth ---------------------------------------------------------
+  /** List workspace members with current balances (capped at 500). */
+  listMembers(slug, opts = {}) {
+    return this.http.requestJson(`/workspaces/${seg(slug)}/members`, {
+      signal: opts.signal
+    });
+  }
+  /**
+   * Grant credits to a member from the workspace pool. Idempotent on
+   * `body.idempotency_key` — replays return the original purchase.
+   */
+  grantCredits(slug, memberId, body, opts = {}) {
+    return this.http.requestJson(
+      `/workspaces/${seg(slug)}/members/${seg(memberId)}/credits`,
+      { method: "POST", body, signal: opts.signal }
+    );
+  }
+  // -- Public (no auth) ----------------------------------------------------
+  /**
+   * Send a one-time SMS verification code for public signup. Requires the
+   * workspace to have `public_sms_signup_enabled`.
+   */
+  async sendSmsCode(slug, body, opts = {}) {
+    await this.http.requestJson(`/workspaces/${seg(slug)}/sms/send`, {
+      method: "POST",
+      body,
+      signal: opts.signal
+    });
+  }
+  /** Verify an SMS code and mint a member session JWT in one shot. */
+  verifySmsCode(slug, body, opts = {}) {
+    return this.http.requestJson(`/workspaces/${seg(slug)}/sms/verify`, {
+      method: "POST",
+      body,
+      signal: opts.signal
+    });
+  }
+  /**
+   * A slug-bound handle so you don't repeat the slug on every call.
+   * `client.workspaces.workspace('acme').listMembers()`.
+   */
+  workspace(slug) {
+    return new Workspace(this, slug);
+  }
+};
+var Workspace = class {
+  constructor(client, slug) {
+    this.client = client;
+    this.slug = slug;
+  }
+  listMembers(opts) {
+    return this.client.listMembers(this.slug, opts);
+  }
+  provisionMember(body, opts) {
+    return this.client.provisionMember(this.slug, body, opts);
+  }
+  suspendMember(memberId, opts) {
+    return this.client.suspendMember(this.slug, memberId, opts);
+  }
+  grantCredits(memberId, body, opts) {
+    return this.client.grantCredits(this.slug, memberId, body, opts);
+  }
+  mintSession(body, opts) {
+    return this.client.mintSession(this.slug, body, opts);
+  }
+  sendSmsCode(body, opts) {
+    return this.client.sendSmsCode(this.slug, body, opts);
+  }
+  verifySmsCode(body, opts) {
+    return this.client.verifySmsCode(this.slug, body, opts);
+  }
+};
+
+// src/client.ts
+var OpenhexClient = class {
+  constructor(config = {}) {
+    this.config = config;
+    const http = new HttpClient({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      loginType: config.loginType,
+      actAs: config.actAs,
+      timeoutMs: config.timeoutMs,
+      fetch: config.fetch
+    });
+    this.http = http;
+    this.chat = new AgentChatClient(http);
+    this.workspaces = new WorkspaceClient(http);
+  }
+  /** Low- and high-level chat API (conversations protocol). */
+  chat;
+  /**
+   * Workspace API (`/api/v2/workspaces/*`) — provision members, mint
+   * member sessions, grant credits, read reporting. Auth is whatever
+   * token the client is configured with (a `sk_ws_…` workspace API key
+   * for partner calls, or the owner's JWT for SP-admin calls).
+   */
+  workspaces;
+  http;
+  /**
+   * A slug-bound workspace handle so you don't repeat the slug on every
+   * call. Equivalent to `client.workspaces.workspace(slug)`.
+   */
+  workspace(slug) {
+    return this.workspaces.workspace(slug);
+  }
+  /**
+   * Training-mode chat with an agent AS ITS OWNER (the dev/train protocol —
+   * the agent runs in CREATION/TRAINING mode and can learn from feedback).
+   * Defaults to the client's configured `agentId`; pass one to override.
+   */
+  training(agentId) {
+    const id = agentId ?? this.config.agentId;
+    if (!id) {
+      throw new Error("training() needs an agent id: set { agentId } on the client or pass one.");
+    }
+    return new TrainingChat(this.http, id);
+  }
+  /** Default target agents for new conversations (from `config.agentId`). */
+  defaultTargets(opts) {
+    if (opts?.targetAgentIds) return opts.targetAgentIds;
+    return this.config.agentId ? [this.config.agentId] : void 0;
+  }
+  /** Build a {@link SendRequest} from a message + turn options. */
+  buildRequest(message, opts) {
+    if (opts?.conversationId) return { message, conversationId: opts.conversationId };
+    const targetAgentIds = this.defaultTargets(opts);
+    if (!targetAgentIds) {
+      throw new Error(
+        "No target agent: set { agentId } on the client, or pass { targetAgentIds } / { conversationId } in options."
+      );
+    }
+    return { message, targetAgentIds };
+  }
+  /**
+   * Send a message and resolve with the aggregated turn. Creates a new
+   * conversation routed to the configured agent unless `opts.conversationId`
+   * is given. The returned turn carries `conversationId` to continue.
+   */
+  sendMessage(message, opts = {}) {
+    return this.chat.sendMessage(this.buildRequest(message, opts), opts);
+  }
+  /** Stream a single turn's records (see {@link sendMessage}). */
+  runTurn(message, opts = {}) {
+    return this.chat.runTurn(this.buildRequest(message, opts), opts);
+  }
+  /**
+   * Start a stateful conversation that remembers its id across turns,
+   * defaulting its target agents to the configured agent.
+   */
+  conversation(opts = {}) {
+    return this.chat.conversation({
+      conversationId: opts.conversationId,
+      targetAgentIds: opts.targetAgentIds ?? this.defaultTargets()
+    });
+  }
+  /**
+   * Run an agent query using this client's connection + default options.
+   * Per-call `options` are shallow-merged over the client defaults.
+   */
+  query(params) {
+    return query({
+      prompt: params.prompt,
+      options: {
+        apiKey: this.config.apiKey,
+        baseUrl: this.config.baseUrl,
+        agentId: this.config.agentId,
+        ...this.config.defaultOptions,
+        ...params.options
+      }
+    });
+  }
+  /** List recent sessions for the configured agent. */
+  async listSessions() {
+    throw new NotImplementedError("OpenhexClient.listSessions");
+  }
+  /** Fetch metadata for a single session. */
+  async getSession(_sessionId) {
+    throw new NotImplementedError("OpenhexClient.getSession");
+  }
+  /** Delete a session and its stored context. */
+  async deleteSession(_sessionId) {
+    throw new NotImplementedError("OpenhexClient.deleteSession");
+  }
+};
+
+// src/tools/index.ts
+function tool(name, description, inputSchema, handler) {
+  return { name, description, inputSchema, handler };
+}
+function createSdkMcpServer(config) {
+  return {
+    type: "sdk",
+    name: config.name,
+    version: config.version ?? "0.0.1",
+    tools: config.tools
+  };
+}
+
+// src/hooks.ts
+function hookMatcher(matcher, ...hooks) {
+  return matcher === void 0 ? { hooks } : { matcher, hooks };
+}
+export {
+  API_PREFIX,
+  AbortError,
+  AgentChatClient,
+  ApiError,
+  AuthenticationError,
+  Backoff,
+  Conversation,
+  DEFAULT_BASE_URL,
+  HttpClient,
+  HttpTransport,
+  NotImplementedError,
+  OpenhexClient,
+  OpenhexSdkError,
+  TrainingChat,
+  Workspace,
+  WorkspaceClient,
+  createSdkMcpServer,
+  delay,
+  extractText,
+  extractToolCalls,
+  hookMatcher,
+  isAgentRecord,
+  isInterrupt,
+  isTurnComplete,
+  parseSSEStream,
+  query,
+  tool
+};
+//# sourceMappingURL=index.js.map