10xgraph-client 0.0.0-stage → 0.6.0

package/dist/index.js

@@ -0,0 +1,2664 @@
+class b {
+  constructor(e = "url", r, o, s, n, i, a, c, d, h, l, u) {
+    this.kind = "url", this.kind = e, this.url = r, this.file_id = o, this.data_base64 = s, this.mime_type = n, this.size_bytes = i, this.sha256 = a, this.filename = c, this.width = d, this.height = h, this.duration_ms = l, this.page = u;
+  }
+}
+class it {
+  constructor(e, r, o, s, n) {
+    this.url = e, this.file_id = r, this.page = o, this.index = s, this.title = n;
+  }
+}
+class S {
+  constructor(e = "", r = []) {
+    this.type = "text", this.text = "", this.annotations = [], this.text = e, this.annotations = r;
+  }
+}
+class v {
+  constructor(e = new b(), r, o) {
+    this.type = "image", this.media = new b(), this.media = e, this.alt_text = r, this.bbox = o;
+  }
+}
+class H {
+  constructor(e = new b(), r, o, s) {
+    this.type = "audio", this.media = new b(), this.media = e, this.transcript = r, this.sample_rate = o, this.channels = s;
+  }
+}
+class B {
+  constructor(e = new b(), r) {
+    this.type = "video", this.media = new b(), this.media = e, this.thumbnail = r;
+  }
+}
+class J {
+  constructor(e = new b(), r, o) {
+    this.type = "document", this.media = new b(), this.media = e, this.pages = r, this.excerpt = o;
+  }
+}
+class at {
+  constructor(e = "", r, o) {
+    this.type = "data", this.mime_type = "", this.mime_type = e, this.data_base64 = r, this.media = o;
+  }
+}
+class lt {
+  constructor(e = "", r = "", o = {}, s) {
+    this.type = "tool_call", this.id = "", this.name = "", this.args = {}, this.id = e, this.name = r, this.args = o, this.tool_type = s;
+  }
+}
+class ct {
+  constructor(e = "", r = "", o = {}, s = "remote") {
+    this.type = "remote_tool_call", this.id = "", this.name = "", this.args = {}, this.tool_type = "remote", this.id = e, this.name = r, this.args = o, this.tool_type = s;
+  }
+}
+class G {
+  constructor(e) {
+    this.type = "tool_result", this.call_id = "", this.is_error = !1, this.call_id = e.call_id, this.output = e.output, this.status = e.status, this.is_error = e.is_error;
+  }
+}
+class ht {
+  constructor(e = "", r) {
+    this.type = "reasoning", this.summary = "", this.summary = e, this.details = r;
+  }
+}
+class dt {
+  constructor(e = "citation", r = [], o) {
+    this.type = "annotation", this.kind = "citation", this.refs = [], this.kind = e, this.refs = r, this.spans = o;
+  }
+}
+class ut {
+  constructor(e = "", r, o) {
+    this.type = "error", this.message = "", this.message = e, this.code = r, this.data = o;
+  }
+}
+class mt {
+  constructor() {
+    this.completion_tokens = 0, this.prompt_tokens = 0, this.total_tokens = 0, this.reasoning_tokens = 0, this.cache_creation_input_tokens = 0, this.cache_read_input_tokens = 0, this.image_tokens = 0, this.audio_tokens = 0;
+  }
+}
+class C {
+  constructor(e, r, o = null) {
+    this.message_id = null, this.content = [], this.delta = !1, this.timestamp = Date.now(), this.metadata = {}, this.role = e, this.content = r, this.message_id = o;
+  }
+  static text_message(e, r = "user", o = null) {
+    return new C(r, [{ type: "text", text: e }], o);
+  }
+  static tool_message(e, r = null, o = {}) {
+    const s = new C("tool", e, r);
+    return s.metadata = o, s;
+  }
+  text() {
+    return this.content.map((e) => {
+      if (e.type === "text")
+        return e.text;
+      if (e.type === "tool_result") {
+        const r = e.output;
+        return typeof r == "string" ? r : JSON.stringify(r);
+      }
+      return "";
+    }).join("");
+  }
+  attach_media(e, r) {
+    let o;
+    switch (r) {
+      case "image":
+        o = { type: "image", media: e };
+        break;
+      case "audio":
+        o = { type: "audio", media: e };
+        break;
+      case "video":
+        o = { type: "video", media: e };
+        break;
+      case "document":
+        o = { type: "document", media: e };
+        break;
+      default:
+        throw new Error(`Unsupported media type: ${r}`);
+    }
+    this.content.push(o);
+  }
+  // ------------------------------------------------------------------
+  // Multimodal convenience constructors (Sprint 5.3)
+  // ------------------------------------------------------------------
+  /**
+   * Create a message with an image (via URL or base64).
+   *
+   * @example
+   * ```ts
+   * const msg = Message.withImage('Describe this', 'https://example.com/photo.jpg');
+   * const msg2 = Message.withImage('Describe this', 'data:image/png;base64,...');
+   * ```
+   */
+  static withImage(e, r, o = "user") {
+    return new C(o, [
+      new S(e),
+      new v(new b("url", r, void 0, void 0, void 0))
+    ]);
+  }
+  /**
+   * Create a message with a file reference (e.g. from uploadFile result).
+   *
+   * @example
+   * ```ts
+   * const upload = await client.uploadFile(pdfFile);
+   * const msg = Message.withFile('Summarize this PDF', upload.data.file_id, 'application/pdf');
+   * ```
+   */
+  static withFile(e, r, o, s = "user") {
+    const n = new b("file_id", void 0, r, void 0, o), i = o?.startsWith("image/"), a = o?.startsWith("audio/"), c = o?.startsWith("video/");
+    let d;
+    return i ? d = new v(n) : a ? d = new H(n) : c ? d = new B(n) : d = new J(n), new C(s, [new S(e), d]);
+  }
+  /**
+   * Create a multimodal message with arbitrary content blocks.
+   *
+   * @example
+   * ```ts
+   * const msg = Message.multimodal([
+   *   new TextBlock('Look at these'),
+   *   new ImageBlock(new MediaRef('url', 'https://...')),
+   *   new ImageBlock(new MediaRef('url', 'https://...')),
+   * ]);
+   * ```
+   */
+  static multimodal(e, r = "user") {
+    return new C(r, e);
+  }
+}
+function W(t) {
+  const e = t ?? {}, { type: r, properties: o, required: s, ...n } = e;
+  return {
+    ...n,
+    type: r ?? "object",
+    properties: o ?? {},
+    required: s ?? []
+  };
+}
+class z {
+  constructor(e = []) {
+    this.tools = /* @__PURE__ */ new Map(), this.toolsByNode = /* @__PURE__ */ new Map();
+    for (const r of e)
+      this.tools.set(r.name, r), r.node && (this.toolsByNode.has(r.node) || this.toolsByNode.set(r.node, /* @__PURE__ */ new Map()), this.toolsByNode.get(r.node).set(r.name, r));
+  }
+  /**
+   * Register a new tool
+   */
+  registerTool(e) {
+    const r = async (o) => e.handler(o);
+    Object.defineProperty(r, "name", {
+      value: e.name,
+      writable: !0,
+      configurable: !0
+    }), Object.defineProperty(r, "description", {
+      value: e.description,
+      writable: !0,
+      configurable: !0
+    }), Object.defineProperty(r, "parameters", {
+      value: e.parameters,
+      writable: !0,
+      configurable: !0
+    }), Object.defineProperty(r, "node", {
+      value: e.node,
+      writable: !0,
+      configurable: !0
+    }), this.tools.set(e.name, r), e.node && (this.toolsByNode.has(e.node) || this.toolsByNode.set(e.node, /* @__PURE__ */ new Map()), this.toolsByNode.get(e.node).set(e.name, r));
+  }
+  /**
+   * Get tools for a specific node
+   */
+  getToolsForNode(e) {
+    const r = this.toolsByNode.get(e);
+    return r ? Array.from(r.values()) : [];
+  }
+  /**
+   * Get all tools in OpenAI-compatible format
+   */
+  all_tools() {
+    const e = [];
+    for (const [r, o] of this.tools) {
+      const s = {
+        type: "function",
+        function: {
+          name: r,
+          description: o.description || `Execute ${r}`,
+          parameters: W(o.parameters)
+        }
+      };
+      e.push(s);
+    }
+    return e;
+  }
+  /**
+   * Extract and execute all tool calls from the response
+   * Returns an array of tool result messages
+   */
+  async executeToolCalls(e) {
+    const r = [];
+    for (const s of e)
+      if (s.content)
+        for (const n of s.content)
+          n.type === "remote_tool_call" && r.push(n);
+    const o = [];
+    for (const s of r) {
+      const n = s.name;
+      if (this.tools.has(n)) {
+        const i = this.tools.get(n);
+        try {
+          const a = await i(s.args), c = new G({
+            call_id: s.id,
+            output: a,
+            status: "completed",
+            is_error: !1
+          });
+          o.push(C.tool_message([c]));
+        } catch (a) {
+          const c = a instanceof Error ? a.message : String(a), d = new G({
+            call_id: s.id,
+            output: { error: c },
+            status: "failed",
+            is_error: !0
+          });
+          o.push(C.tool_message([d]));
+        }
+      } else {
+        const i = new G({
+          call_id: s.id,
+          output: { error: `Tool '${n}' not found` },
+          status: "failed",
+          is_error: !0
+        });
+        o.push(C.tool_message([i]));
+      }
+    }
+    return o;
+  }
+}
+class g extends Error {
+  constructor(e, r, o, s, n, i = [], a, c, d, h) {
+    super(e), this.name = "TenxGraphError", this.statusCode = r, this.errorCode = o, this.requestId = s, this.timestamp = n, this.details = i, this.context = a, this.endpoint = c, this.method = d, this.recoverySuggestion = h;
+    const l = Error.captureStackTrace;
+    l && l(this, this.constructor);
+  }
+  /**
+   * Get a user-friendly error message with recovery suggestion
+   */
+  getUserMessage() {
+    return this.recoverySuggestion ? `${this.message}
+
+Suggestion: ${this.recoverySuggestion}` : this.message;
+  }
+  /**
+   * Get full error details for debugging
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      errorCode: this.errorCode,
+      requestId: this.requestId,
+      timestamp: this.timestamp,
+      details: this.details,
+      context: this.context,
+      endpoint: this.endpoint,
+      method: this.method,
+      recoverySuggestion: this.recoverySuggestion,
+      stack: this.stack
+    };
+  }
+}
+class R extends g {
+  constructor(e, r, o, s = []) {
+    super(e, 400, "BAD_REQUEST", r, o, s), this.name = "BadRequestError";
+  }
+}
+class $ extends g {
+  constructor(e, r, o, s = []) {
+    super(e, 401, "AUTHENTICATION_FAILED", r, o, s), this.name = "AuthenticationError";
+  }
+}
+class k extends g {
+  constructor(e, r, o, s = []) {
+    super(e, 403, "PERMISSION_ERROR", r, o, s), this.name = "PermissionError";
+  }
+}
+class A extends g {
+  constructor(e, r, o, s = []) {
+    super(e, 404, "RESOURCE_NOT_FOUND", r, o, s), this.name = "NotFoundError";
+  }
+}
+class I extends g {
+  constructor(e, r, o, s = []) {
+    super(e, 422, "VALIDATION_ERROR", r, o, s), this.name = "ValidationError";
+  }
+}
+class O extends g {
+  constructor(e, r, o, s = "INTERNAL_SERVER_ERROR", n = [], i = 500) {
+    super(e, i, s, r, o, n), this.name = "ServerError";
+  }
+}
+class V extends g {
+  constructor(e, r, o, s = [], n) {
+    super(
+      e,
+      500,
+      "GRAPH_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "Check your graph configuration and ensure all nodes are properly connected."
+    ), this.name = "GraphError";
+  }
+}
+class Y extends g {
+  constructor(e, r, o, s = [], n, i) {
+    super(
+      e,
+      500,
+      "NODE_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "Review the node implementation and ensure all required inputs are provided."
+    ), this.name = "NodeError", this.nodeName = i;
+  }
+}
+class K extends g {
+  constructor(e, r, o, s = [], n, i) {
+    super(
+      e,
+      500,
+      "GRAPH_RECURSION_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "Consider increasing the recursion_limit parameter or check for infinite loops in your graph."
+    ), this.name = "GraphRecursionError", this.recursionLimit = i;
+  }
+}
+class Z extends g {
+  constructor(e, r, o, s = [], n) {
+    super(
+      e,
+      500,
+      "STORAGE_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "Check your storage configuration and ensure the storage backend is accessible."
+    ), this.name = "StorageError";
+  }
+}
+class Q extends g {
+  constructor(e, r, o, s = [], n) {
+    super(
+      e,
+      503,
+      "TRANSIENT_STORAGE_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "This is a temporary issue. Please retry your request after a short delay."
+    ), this.name = "TransientStorageError";
+  }
+}
+class X extends g {
+  constructor(e, r, o, s = [], n) {
+    super(
+      e,
+      500,
+      "METRICS_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "Check your metrics configuration. This error typically doesn't affect core functionality."
+    ), this.name = "MetricsError";
+  }
+}
+class q extends g {
+  constructor(e, r, o, s = [], n, i, a) {
+    super(
+      e,
+      422,
+      "SCHEMA_VERSION_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "Update your client to match the server schema version or contact support."
+    ), this.name = "SchemaVersionError", this.expectedVersion = i, this.actualVersion = a;
+  }
+}
+class ee extends g {
+  constructor(e, r, o, s = [], n) {
+    super(
+      e,
+      500,
+      "SERIALIZATION_ERROR",
+      r,
+      o,
+      s,
+      n,
+      void 0,
+      void 0,
+      "Ensure your data format is compatible with the API schema."
+    ), this.name = "SerializationError";
+  }
+}
+async function te(t) {
+  try {
+    const e = t.headers.get("content-type");
+    return e && e.includes("application/json") ? await t.json() : null;
+  } catch {
+    return null;
+  }
+}
+async function p(t, e, r, o) {
+  const s = await te(t);
+  if (s) {
+    const { metadata: a, error: c } = s, d = c.message || e || `HTTP error ${t.status}`, h = a.request_id || "unknown", l = a.timestamp || (/* @__PURE__ */ new Date()).toISOString(), u = c.details || [], T = c.code || "";
+    if (T.startsWith("GRAPH_RECURSION"))
+      return new K(d, h, l, u);
+    if (T.startsWith("GRAPH"))
+      return new V(d, h, l, u);
+    if (T.startsWith("NODE"))
+      return new Y(d, h, l, u);
+    if (T.startsWith("TRANSIENT_STORAGE"))
+      return new Q(d, h, l, u);
+    if (T.startsWith("STORAGE"))
+      return new Z(d, h, l, u);
+    if (T.startsWith("METRICS"))
+      return new X(d, h, l, u);
+    if (T.startsWith("SCHEMA_VERSION"))
+      return new q(d, h, l, u);
+    if (T.startsWith("SERIALIZATION"))
+      return new ee(d, h, l, u);
+    switch (t.status) {
+      case 400:
+        return new R(d, h, l, u);
+      case 401:
+        return new $(d, h, l, u);
+      case 403:
+        return new k(d, h, l, u);
+      case 404:
+        return new A(d, h, l, u);
+      case 422:
+        return new I(d, h, l, u);
+      case 500:
+      case 502:
+      case 503:
+      case 504:
+        return new O(
+          d,
+          h,
+          l,
+          T || "INTERNAL_SERVER_ERROR",
+          u,
+          t.status
+        );
+      default:
+        return new g(
+          d,
+          t.status,
+          T || "UNKNOWN_ERROR",
+          h,
+          l,
+          u,
+          void 0,
+          r,
+          o
+        );
+    }
+  }
+  const n = e || `HTTP error! status: ${t.status}`, i = (/* @__PURE__ */ new Date()).toISOString();
+  switch (t.status) {
+    case 400:
+      return new R(n, "unknown", i);
+    case 401:
+      return new $(n, "unknown", i);
+    case 403:
+      return new k(n, "unknown", i);
+    case 404:
+      return new A(n, "unknown", i);
+    case 422:
+      return new I(n, "unknown", i);
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new O(
+        n,
+        "unknown",
+        i,
+        "INTERNAL_SERVER_ERROR",
+        [],
+        t.status
+      );
+    default:
+      return new g(
+        n,
+        t.status,
+        "UNKNOWN_ERROR",
+        "unknown",
+        i,
+        [],
+        void 0,
+        r,
+        o
+      );
+  }
+}
+function _(t, e, r) {
+  if (r != null) {
+    for (const o of Object.keys(t))
+      o.toLowerCase() === e.toLowerCase() && delete t[o];
+    t[e] = r;
+  }
+}
+function N(t, e) {
+  if (e) {
+    if (e instanceof Headers) {
+      e.forEach((r, o) => {
+        _(t, o, r);
+      });
+      return;
+    }
+    if (Array.isArray(e)) {
+      for (const [r, o] of e)
+        _(t, r, o);
+      return;
+    }
+    for (const [r, o] of Object.entries(e))
+      o !== void 0 && _(t, r, String(o));
+  }
+}
+function re(t, e) {
+  return Object.keys(t).some(
+    (r) => r.toLowerCase() === e.toLowerCase()
+  );
+}
+function oe(t) {
+  const e = globalThis.Buffer;
+  if (e)
+    return e.from(t, "utf-8").toString("base64");
+  if (typeof btoa == "function") {
+    const r = new TextEncoder().encode(t);
+    let o = "";
+    for (const s of r)
+      o += String.fromCharCode(s);
+    return btoa(o);
+  }
+  throw new Error("Basic authentication is not supported in this runtime");
+}
+function se(t, e) {
+  if (!e)
+    return;
+  if (e.type === "bearer") {
+    _(t, "Authorization", `Bearer ${e.token}`);
+    return;
+  }
+  if (e.type === "basic") {
+    const o = oe(`${e.username}:${e.password}`);
+    _(t, "Authorization", `Basic ${o}`);
+    return;
+  }
+  const r = e.prefix ? `${e.prefix} ${e.value}` : e.value;
+  _(t, e.name, r);
+}
+function m(t, e) {
+  const r = {};
+  return N(r, e), N(r, t.headers), t.auth ? se(r, t.auth) : t.authToken && !re(r, "Authorization") && _(r, "Authorization", `Bearer ${t.authToken}`), r;
+}
+function f(t) {
+  return t.credentials ? { credentials: t.credentials } : {};
+}
+function ft(t) {
+  return { type: "bearer", token: t };
+}
+function pt(t, e) {
+  return { type: "basic", username: t, password: e };
+}
+function gt(t, e, r) {
+  return { type: "header", name: t, value: e, prefix: r };
+}
+async function ne(t) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Pinging server at", t.baseUrl);
+    const e = new AbortController(), r = setTimeout(() => e.abort(), t.timeout), o = await fetch(`${t.baseUrl}/ping`, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      signal: e.signal
+    });
+    if (clearTimeout(r), !o.ok)
+      throw console.warn(`TenxGraphClient: Ping failed with HTTP ${o.status}`), await p(o, "Ping request failed", "/ping", "GET");
+    const s = await o.json();
+    return t.debug && console.info("TenxGraphClient: Ping successful", s), s;
+  } catch (e) {
+    throw t.debug && console.debug("TenxGraphClient: Ping failed:", e), e.name === "AbortError" ? (console.warn(`TenxGraphClient: Ping timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: Ping failed:", e), e);
+  }
+}
+async function ie(t) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Fetching graph from", t.baseUrl);
+    const e = new AbortController(), r = setTimeout(() => e.abort(), t.timeout), o = await fetch(`${t.baseUrl}/v1/graph`, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: e.signal
+    });
+    if (clearTimeout(r), !o.ok)
+      throw console.warn(`TenxGraphClient: Graph fetch failed with HTTP ${o.status}`), await p(
+        o,
+        "Graph fetch failed",
+        "/v1/graph",
+        "GET"
+      );
+    const s = await o.json();
+    return t.debug && console.info("TenxGraphClient: Graph fetch successful", s), s;
+  } catch (e) {
+    throw t.debug && console.debug("TenxGraphClient: Graph fetch failed:", e), e.name === "AbortError" ? (console.warn(`TenxGraphClient: Graph fetch timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: Graph fetch failed:", e), e);
+  }
+}
+async function ae(t) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Fetching graph tools from", t.baseUrl);
+    const e = new AbortController(), r = setTimeout(() => e.abort(), t.timeout), o = await fetch(`${t.baseUrl}/v1/graph/tools`, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: e.signal
+    });
+    if (clearTimeout(r), !o.ok)
+      throw console.warn(`TenxGraphClient: Graph tools fetch failed with HTTP ${o.status}`), await p(
+        o,
+        "Graph tools fetch failed",
+        "/v1/graph/tools",
+        "GET"
+      );
+    const s = await o.json();
+    return t.debug && console.info("TenxGraphClient: Graph tools fetch successful", s), s;
+  } catch (e) {
+    throw t.debug && console.debug("TenxGraphClient: Graph tools fetch failed:", e), e.name === "AbortError" ? (console.warn(`TenxGraphClient: Graph tools fetch timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: Graph tools fetch failed:", e), e);
+  }
+}
+async function le(t, e, r) {
+  try {
+    const o = new AbortController(), s = setTimeout(() => o.abort(), t.timeout), n = r ? `?run_id=${encodeURIComponent(r)}` : "", i = await fetch(
+      `${t.baseUrl}/v1/observability/${encodeURIComponent(e)}${n}`,
+      {
+        method: "GET",
+        headers: m(t, {
+          "Content-Type": "application/json",
+          accept: "application/json"
+        }),
+        ...f(t),
+        signal: o.signal
+      }
+    );
+    if (clearTimeout(s), !i.ok)
+      throw await p(
+        i,
+        "Observability fetch failed",
+        `/v1/observability/${e}`,
+        "GET"
+      );
+    return await i.json();
+  } catch (o) {
+    throw o.name === "AbortError" ? new Error(`Request timeout after ${t.timeout}ms`) : o;
+  }
+}
+async function ce(t) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Fetching state schema from", t.baseUrl);
+    const e = new AbortController(), r = setTimeout(() => e.abort(), t.timeout), o = await fetch(`${t.baseUrl}/v1/graph:StateSchema`, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: e.signal
+    });
+    if (clearTimeout(r), !o.ok)
+      throw console.warn(`TenxGraphClient: State schema fetch failed with HTTP ${o.status}`), await p(
+        o,
+        "State schema fetch failed",
+        "/v1/state_schema",
+        "GET"
+      );
+    const s = await o.json();
+    return t.debug && console.info("TenxGraphClient: State schema fetch successful", s), s;
+  } catch (e) {
+    throw t.debug && console.debug("TenxGraphClient: State schema fetch failed:", e), e.name === "AbortError" ? (console.warn(`TenxGraphClient: State schema fetch timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: State schema fetch failed:", e), e);
+  }
+}
+async function he(t, e) {
+  try {
+    t.debug && console.debug(`TenxGraphClient: Fetching thread state for thread ${e}`);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = await fetch(`${t.baseUrl}/v1/threads/${e}/state`, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw console.warn(`TenxGraphClient: Thread state fetch failed with HTTP ${s.status}`), await p(
+        s,
+        "Thread state fetch failed",
+        "/v1/threads/{thread_id}/state",
+        "GET"
+      );
+    const n = await s.json();
+    return t.debug && console.info(
+      `TenxGraphClient: Thread state fetched successfully for thread ${e}`,
+      n
+    ), n;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: Thread state fetch timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Thread state fetch failed:", r), r);
+  }
+}
+async function de(t, e, r) {
+  try {
+    t.debug && (console.debug(`TenxGraphClient: Updating thread state for thread ${e}`), console.debug("TenxGraphClient: Request payload:", JSON.stringify(r, null, 2)));
+    const o = new AbortController(), s = setTimeout(() => o.abort(), t.timeout), n = await fetch(`${t.baseUrl}/v1/threads/${e}/state`, {
+      method: "PUT",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(r),
+      signal: o.signal
+    });
+    if (clearTimeout(s), !n.ok)
+      throw console.warn(`TenxGraphClient: Thread state update failed with HTTP ${n.status}`), await p(
+        n,
+        "Thread state update failed",
+        "/v1/threads/{thread_id}/state",
+        "PUT"
+      );
+    const i = await n.json();
+    return t.debug && console.info(
+      `TenxGraphClient: Thread state updated successfully for thread ${e}`,
+      i
+    ), i;
+  } catch (o) {
+    throw o.name === "AbortError" ? (console.warn(`TenxGraphClient: Thread state update timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Thread state update failed:", o), o);
+  }
+}
+async function ue(t, e) {
+  try {
+    t.debug && console.debug(`TenxGraphClient: Clearing thread state for thread ${e}`);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = await fetch(`${t.baseUrl}/v1/threads/${e}/state`, {
+      method: "DELETE",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw console.warn(`TenxGraphClient: Thread state clear failed with HTTP ${s.status}`), await p(
+        s,
+        "Thread state clear failed",
+        "/v1/threads/{thread_id}/state",
+        "DELETE"
+      );
+    const n = await s.json();
+    return t.debug && console.info(
+      `TenxGraphClient: Thread state cleared successfully for thread ${e}`,
+      n
+    ), n;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: Thread state clear timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Thread state clear failed:", r), r);
+  }
+}
+async function U(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Fetching thread messages for thread", e.threadId);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = new URLSearchParams();
+    e.search !== void 0 && s.append("search", e.search), e.offset !== void 0 && s.append("offset", e.offset.toString()), e.limit !== void 0 && s.append("limit", e.limit.toString());
+    const n = s.toString(), i = `${t.baseUrl}/v1/threads/${e.threadId}/messages${n ? "?" + n : ""}`, a = await fetch(i, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !a.ok)
+      throw console.warn(
+        `TenxGraphClient: Checkpoint messages fetch failed with HTTP ${a.status}`
+      ), await p(
+        a,
+        "Thread messages fetch failed",
+        "/v1/threads/{thread_id}/messages",
+        "GET"
+      );
+    const c = await a.json();
+    return t.debug && console.info("TenxGraphClient: Thread messages fetched successfully", c), c;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Checkpoint messages fetch failed:", r), r;
+  }
+}
+const Tt = U;
+async function me(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Adding thread messages to thread", e.threadId);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/threads/${e.threadId}/messages`, n = {
+      config: e.config,
+      messages: e.messages,
+      metadata: e.metadata || {}
+    }, i = await fetch(s, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(n),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !i.ok)
+      throw console.warn(`TenxGraphClient: Add checkpoint messages failed with HTTP ${i.status}`), await p(
+        i,
+        "Add thread messages failed",
+        "/v1/threads/{thread_id}/messages",
+        "POST"
+      );
+    const a = await i.json();
+    return t.debug && console.info("TenxGraphClient: Thread messages added successfully", a), a;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Add checkpoint messages failed:", r), r;
+  }
+}
+async function fe(t, e) {
+  try {
+    t.debug && console.debug(
+      "TenxGraphClient: Fetching thread message",
+      `thread: ${e.threadId}`,
+      `message: ${e.messageId}`
+    );
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/threads/${e.threadId}/messages/${e.messageId}`, n = await fetch(s, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !n.ok)
+      throw console.warn(`TenxGraphClient: Thread message fetch failed with HTTP ${n.status}`), await p(
+        n,
+        "Thread message fetch failed",
+        "/v1/threads/{thread_id}/messages/{message_id}",
+        "GET"
+      );
+    const i = await n.json();
+    return t.debug && console.info("TenxGraphClient: Thread message fetched successfully", i), i;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Thread message fetch failed:", r), r;
+  }
+}
+async function pe(t, e) {
+  try {
+    t.debug && console.debug(`TenxGraphClient: Fetching thread details for thread ${e}`);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/threads/${e}`, n = await fetch(s, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !n.ok)
+      throw console.warn(`TenxGraphClient: Thread details fetch failed with HTTP ${n.status}`), await p(
+        n,
+        "Thread details fetch failed",
+        "/v1/threads/{thread_id}",
+        "GET"
+      );
+    const i = await n.json();
+    return t.debug && console.info("TenxGraphClient: Thread details fetched successfully", i), i;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: Thread details fetch timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Thread details fetch failed:", r), r);
+  }
+}
+async function ge(t, e) {
+  try {
+    t.debug && console.debug(
+      "TenxGraphClient: Deleting thread message",
+      `thread: ${e.threadId}`,
+      `message: ${e.messageId}`
+    );
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/threads/${e.threadId}/messages/${e.messageId}`, n = await fetch(s, {
+      method: "DELETE",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify({ config: e.config || {} }),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !n.ok)
+      throw console.warn(`TenxGraphClient: Delete thread message failed with HTTP ${n.status}`), await p(
+        n,
+        "Delete thread message failed",
+        "/v1/threads/{thread_id}/messages/{message_id}",
+        "DELETE"
+      );
+    const i = await n.json();
+    return t.debug && console.info("TenxGraphClient: Thread message deleted successfully", i), i;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: Delete thread message timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Delete thread message failed:", r), r);
+  }
+}
+async function Te(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Deleting thread", `thread: ${e.threadId}`);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/threads/${e.threadId}`, n = await fetch(s, {
+      method: "DELETE",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify({ config: e.config || {} }),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !n.ok)
+      throw console.warn(`TenxGraphClient: Delete thread failed with HTTP ${n.status}`), await p(
+        n,
+        "Delete thread failed",
+        "/v1/threads/{thread_id}",
+        "DELETE"
+      );
+    const i = await n.json();
+    return t.debug && console.info("TenxGraphClient: Thread deleted successfully", i), i;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: Delete thread timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Delete thread failed:", r), r);
+  }
+}
+async function ye(t, e) {
+  try {
+    t.debug && (console.debug("TenxGraphClient: Fetching threads list"), e?.search && console.debug(`  Search: ${e.search}`), e?.offset !== void 0 && console.debug(`  Offset: ${e.offset}`), e?.limit !== void 0 && console.debug(`  Limit: ${e.limit}`));
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = new URLSearchParams();
+    e?.search && s.append("search", e.search), e?.offset !== void 0 && s.append("offset", e.offset.toString()), e?.limit !== void 0 && s.append("limit", e.limit.toString());
+    const n = s.toString(), i = `${t.baseUrl}/v1/threads${n ? `?${n}` : ""}`, a = await fetch(i, {
+      method: "GET",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !a.ok)
+      throw console.warn(`TenxGraphClient: Threads list fetch failed with HTTP ${a.status}`), await p(
+        a,
+        "Threads list fetch failed",
+        "/v1/threads",
+        "GET"
+      );
+    const c = await a.json();
+    return t.debug && (console.info("TenxGraphClient: Threads list fetched successfully", c), console.debug(`  Found ${c.data.threads.length} threads`)), c;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: Threads list fetch timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Threads list fetch failed:", r), r);
+  }
+}
+async function we(t, e) {
+  const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout);
+  try {
+    const s = await fetch(`${t.baseUrl}/v1/graph/invoke`, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(e),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw console.warn(`TenxGraphClient: Invoke failed with HTTP ${s.status}`), await p(
+        s,
+        "Invoke request failed",
+        "/v1/invoke",
+        "POST"
+      );
+    return await s.json();
+  } catch (s) {
+    throw clearTimeout(o), s.name === "AbortError" ? (console.warn(`TenxGraphClient: Invoke timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: Invoke failed:", s), s);
+  }
+}
+function be(t) {
+  return !t.data || !t.data.messages ? !1 : t.data.messages.some(
+    (e) => e.content && e.content.some((r) => r.type === "remote_tool_call")
+  );
+}
+async function Ce(t, e, r) {
+  const o = e.recursion_limit || 25;
+  t.debug && (console.debug("TenxGraphClient: Starting invoke with recursion_limit:", o), console.debug("TenxGraphClient: Initial request:", JSON.stringify(e, null, 2)));
+  const s = [];
+  let n = e.messages, i = 0, a = !1, c;
+  const d = e.initial_state, h = e.config, l = e.response_granularity;
+  for (; i < o; ) {
+    i++, t.debug && console.debug(`TenxGraphClient: Iteration ${i}/${o}`);
+    const T = {
+      messages: n,
+      initial_state: i === 1 ? d : void 0,
+      config: h,
+      recursion_limit: o,
+      response_granularity: l
+    };
+    t.debug && console.debug("TenxGraphClient: Request payload:", JSON.stringify(T, null, 2));
+    const y = await we(t, T);
+    c = y, t.debug && (console.info("TenxGraphClient: Invoke successful"), console.debug("TenxGraphClient: Response:", JSON.stringify(y, null, 2))), y.data.messages && s.push(...y.data.messages);
+    const w = be(y);
+    if (r) {
+      const E = {
+        iteration: i,
+        messages: y.data.messages,
+        state: y.data.state,
+        context: y.data.context,
+        summary: y.data.summary,
+        meta: y.data.meta,
+        has_tool_calls: w,
+        is_final: !w
+      };
+      await r(E);
+    }
+    if (w && t.toolExecutor) {
+      t.debug && console.debug("TenxGraphClient: Found remote tool calls, executing...");
+      const E = await t.toolExecutor.executeToolCalls(y.data.messages);
+      t.debug && console.debug(`TenxGraphClient: Executed ${E.length} tool calls`), s.push(...E), n = E.map((F) => _e(F));
+      continue;
+    } else {
+      t.debug && console.debug("TenxGraphClient: No remote tool calls found, finishing");
+      break;
+    }
+  }
+  i >= o && (a = !0, t.debug && console.warn(`TenxGraphClient: Recursion limit of ${o} reached`));
+  const u = {
+    messages: c?.data.messages || [],
+    state: c?.data.state,
+    context: c?.data.context,
+    summary: c?.data.summary,
+    meta: c?.data.meta || { is_new_thread: !1, thread_id: "" },
+    all_messages: s,
+    iterations: i,
+    recursion_limit_reached: a
+  };
+  return t.debug && (console.debug(`TenxGraphClient: Invoke completed after ${i} iterations`), console.debug(`TenxGraphClient: Total messages: ${s.length}`)), u;
+}
+function Ee(t) {
+  return t.map((e) => {
+    const r = {};
+    for (const [o, s] of Object.entries(e))
+      Array.isArray(s) && s.length === 0 || s !== void 0 && (r[o] = s);
+    return r;
+  });
+}
+function _e(t) {
+  const e = {
+    role: t.role,
+    content: Ee(t.content)
+  };
+  return t.message_id !== null && t.message_id !== void 0 ? e.message_id = String(t.message_id) : e.message_id = "0", t.tools_calls && (e.tools_calls = t.tools_calls), t.metadata && Object.keys(t.metadata).length > 0 && (e.metadata = t.metadata), e;
+}
+var x = /* @__PURE__ */ ((t) => (t.MESSAGE = "message", t.UPDATES = "updates", t.STATE = "state", t.ERROR = "error", t))(x || {});
+async function* Ge(t, e) {
+  const r = new TextDecoder();
+  let o = "";
+  try {
+    for (; ; ) {
+      const { done: s, value: n } = await t.read();
+      if (s) {
+        o.trim() && (yield* j(o, e, !0));
+        break;
+      }
+      o += r.decode(n, { stream: !0 }), o = (yield* j(o, e, !1)).remaining;
+    }
+  } finally {
+    t.releaseLock();
+  }
+}
+function* j(t, e, r) {
+  for (; t.includes(`
+`); ) {
+    const o = t.indexOf(`
+`), s = t.slice(0, o).trim();
+    if (t = t.slice(o + 1), s)
+      try {
+        const n = JSON.parse(s);
+        e && console.debug("TenxGraphClient: Stream chunk received (NDJSON):", n.event), yield n;
+      } catch (n) {
+        e && console.warn("TenxGraphClient: Failed to parse NDJSON line:", s.slice(0, 100), n);
+      }
+  }
+  for (; t.trim(); ) {
+    const o = Se(t);
+    if (o)
+      try {
+        const s = JSON.parse(o.json);
+        e && console.debug("TenxGraphClient: Stream chunk received (concat):", s.event), yield s, t = o.remaining;
+      } catch (s) {
+        e && console.warn(
+          "TenxGraphClient: Failed to parse concatenated JSON:",
+          o.json.slice(0, 100),
+          s
+        );
+        break;
+      }
+    else {
+      if (r && t.trim())
+        try {
+          const s = JSON.parse(t.trim());
+          e && console.debug("TenxGraphClient: Final stream chunk:", s.event), yield s, t = "";
+        } catch (s) {
+          e && console.warn(
+            "TenxGraphClient: Failed to parse final buffer:",
+            t.slice(0, 100),
+            s
+          );
+        }
+      break;
+    }
+  }
+  return { remaining: t };
+}
+function Se(t) {
+  if (t = t.trim(), !t || t[0] !== "{")
+    return null;
+  let e = 0, r = !1, o = !1;
+  for (let s = 0; s < t.length; s++) {
+    const n = t[s];
+    if (o) {
+      o = !1;
+      continue;
+    }
+    if (n === "\\") {
+      o = !0;
+      continue;
+    }
+    if (n === '"') {
+      r = !r;
+      continue;
+    }
+    if (!r) {
+      if (n === "{")
+        e++;
+      else if (n === "}" && (e--, e === 0))
+        return {
+          json: t.slice(0, s + 1),
+          remaining: t.slice(s + 1).trim()
+        };
+    }
+  }
+  return null;
+}
+function ve(t) {
+  return t.some(
+    (e) => e.content && e.content.some((r) => r.type === "remote_tool_call")
+  );
+}
+async function* Re(t, e) {
+  const r = e.recursion_limit || 25;
+  t.debug && (console.debug("TenxGraphClient: Starting stream invoke with recursion_limit:", r), console.debug("TenxGraphClient: Initial request:", JSON.stringify(e, null, 2)));
+  let o = e.messages, s = 0;
+  const n = e.initial_state, i = e.config, a = e.response_granularity;
+  for (; s < r; ) {
+    s++, t.debug && console.debug(`TenxGraphClient: Stream iteration ${s}/${r}`);
+    const c = {
+      messages: o,
+      initial_state: s === 1 ? n : void 0,
+      config: i,
+      recursion_limit: r,
+      response_granularity: a
+    };
+    t.debug && console.debug(
+      "TenxGraphClient: Stream request payload:",
+      JSON.stringify(c, null, 2)
+    );
+    const d = new AbortController(), h = setTimeout(() => d.abort(), t.timeout);
+    try {
+      const l = await fetch(`${t.baseUrl}/v1/graph/stream`, {
+        method: "POST",
+        headers: m(t, {
+          "Content-Type": "application/json",
+          Accept: "application/x-ndjson, application/json"
+        }),
+        ...f(t),
+        body: JSON.stringify(c),
+        signal: d.signal
+      });
+      if (clearTimeout(h), !l.ok)
+        throw console.warn(`TenxGraphClient: Stream failed with HTTP ${l.status}`), await p(
+          l,
+          "Stream request failed",
+          "/v1/stream",
+          "POST"
+        );
+      if (!l.body)
+        throw new Error("No response body for stream");
+      const u = [], T = l.body.getReader();
+      for await (const w of Ge(T, t.debug))
+        yield w, w.message && u.push(w.message);
+      if (t.debug && (console.info("TenxGraphClient: Stream iteration completed"), console.debug("TenxGraphClient: Received", u.length, "messages")), ve(u) && t.toolExecutor) {
+        t.debug && console.debug("TenxGraphClient: Found remote tool calls, executing...");
+        const w = await t.toolExecutor.executeToolCalls(u);
+        t.debug && console.debug(`TenxGraphClient: Executed ${w.length} tool calls`), o = w.map((E) => P(E));
+        continue;
+      } else {
+        t.debug && console.debug("TenxGraphClient: No remote tool calls found, finishing");
+        break;
+      }
+    } catch (l) {
+      throw clearTimeout(h), l.name === "AbortError" ? (console.warn(`TenxGraphClient: Stream timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: Stream failed:", l), l);
+    }
+  }
+  s >= r && t.debug && console.warn(`TenxGraphClient: Recursion limit of ${r} reached`), t.debug && console.debug(`TenxGraphClient: Stream invoke completed after ${s} iterations`);
+}
+function $e(t) {
+  return t.map((e) => {
+    const r = {};
+    for (const [o, s] of Object.entries(e))
+      Array.isArray(s) && s.length === 0 || s !== void 0 && (r[o] = s);
+    return r;
+  });
+}
+function P(t) {
+  const e = {
+    role: t.role,
+    content: $e(t.content)
+  };
+  return t.message_id !== null && t.message_id !== void 0 ? e.message_id = String(t.message_id) : e.message_id = "0", t.tools_calls && (e.tools_calls = t.tools_calls), t.metadata && Object.keys(t.metadata).length > 0 && (e.metadata = t.metadata), e;
+}
+const ke = "10xgraph-bearer";
+function Ae(t) {
+  return t.auth ? t.auth.type === "bearer" ? t.auth.token : null : t.authToken ? t.authToken : null;
+}
+function D(t, e) {
+  return t.baseUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:").replace(/\/$/, "") + e;
+}
+function M(t, e) {
+  const r = e.webSocketImpl ?? globalThis.WebSocket;
+  if (!r)
+    throw new Error(
+      "No WebSocket implementation available. In Node < 21 pass `webSocketImpl` in the client config (e.g. the `ws` package: `new TenxGraphClient({ ..., webSocketImpl: WebSocket })`)."
+    );
+  const o = Ae(e), s = o ? [ke, o] : void 0, n = m(e), i = n.Authorization ?? n.authorization;
+  if (i)
+    try {
+      return new r(t, s, { headers: { Authorization: i } });
+    } catch {
+    }
+  return new r(t, s);
+}
+function Ie(t) {
+  return t.some(
+    (e) => e.content && e.content.some((r) => r.type === "remote_tool_call")
+  );
+}
+async function* Oe(t, e) {
+  const r = D(t, "/v1/graph/ws");
+  t.debug && console.debug("TenxGraphClient [WS]: connecting to", r);
+  const o = M(r, t), s = [];
+  let n = null;
+  const i = (h) => {
+    if (s.push(h), n) {
+      const l = n;
+      n = null, l();
+    }
+  }, a = () => new Promise((h) => {
+    s.length > 0 ? h() : n = h;
+  });
+  o.addEventListener("message", (h) => {
+    try {
+      const l = JSON.parse(h.data);
+      i(l);
+    } catch (l) {
+      t.debug && console.warn("TenxGraphClient [WS]: failed to parse chunk:", l);
+    }
+  }), o.addEventListener("error", () => {
+    i(new Error("WebSocket error"));
+  }), o.addEventListener("close", (h) => {
+    t.debug && console.debug("TenxGraphClient [WS]: connection closed, code=", h.code), i("close");
+  }), await new Promise((h, l) => {
+    if (o.readyState === 1) {
+      h();
+      return;
+    }
+    o.addEventListener("open", () => h(), { once: !0 }), o.addEventListener("error", () => l(new Error("WebSocket connection failed")), {
+      once: !0
+    });
+  }), t.debug && console.debug("TenxGraphClient [WS]: connected");
+  let c = e.config?.thread_id, d = {
+    invoke_type: "fresh",
+    messages: e.messages,
+    initial_state: e.initial_state,
+    config: e.config,
+    recursion_limit: e.recursion_limit ?? 25,
+    response_granularity: e.response_granularity
+  };
+  try {
+    e: for (; ; ) {
+      t.debug && console.debug(
+        `TenxGraphClient [WS]: sending ${d.invoke_type} request, thread_id=${c ?? "new"}`
+      ), o.send(JSON.stringify(d));
+      const h = [];
+      t: for (; ; ) {
+        await a();
+        const l = s.shift();
+        if (l === "close")
+          break e;
+        if (l instanceof Error)
+          throw l;
+        const u = l;
+        if (u.thread_id && (c = u.thread_id), u.metadata?.thread_id && (c = u.metadata.thread_id), u.event === x.UPDATES && u.data?.status === "done")
+          break t;
+        u.message && h.push(u.message), yield u;
+      }
+      if (t.debug && console.debug(
+        `TenxGraphClient [WS]: run complete, ${h.length} messages collected`
+      ), Ie(h) && t.toolExecutor) {
+        t.debug && console.debug("TenxGraphClient [WS]: remote tool calls detected, executing…");
+        const l = await t.toolExecutor.executeToolCalls(h);
+        t.debug && console.debug(
+          `TenxGraphClient [WS]: ${l.length} tool result(s) ready, resuming`
+        ), d = {
+          invoke_type: "resume",
+          tool_result: l.map(P),
+          config: { ...e.config ?? {}, thread_id: c },
+          recursion_limit: e.recursion_limit ?? 25,
+          response_granularity: e.response_granularity
+        };
+      } else
+        break e;
+    }
+  } finally {
+    (o.readyState === 1 || o.readyState === 0) && o.close(1e3), t.debug && console.debug("TenxGraphClient [WS]: stream finished");
+  }
+}
+const Ne = 24e3, yt = 16e3;
+function je() {
+  const t = globalThis.crypto;
+  return t?.randomUUID ? t.randomUUID() : "rt-" + Math.abs(Ue(String(Date.now()))).toString(36);
+}
+function Ue(t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++)
+    e = (e << 5) - e + t.charCodeAt(r), e |= 0;
+  return e;
+}
+function xe(t) {
+  if (t instanceof ArrayBuffer)
+    return new Uint8Array(t);
+  if (ArrayBuffer.isView(t)) {
+    const e = t;
+    return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+  }
+  return null;
+}
+class Pe {
+  constructor(e, r, o) {
+    this.resumptionHandle = null, this.ws = null, this.listeners = {}, this.readyResolved = !1, this.closedByUser = !1, this.fatal = !1, this.reconnectAttempts = 0, this.ctx = e, this.threadId = r.thread_id ?? je(), this.init = { ...r, thread_id: this.threadId }, this.reconnectCfg = {
+      enabled: o?.reconnect?.enabled ?? !0,
+      baseDelay: o?.reconnect?.baseDelay ?? 0.5,
+      maxDelay: o?.reconnect?.maxDelay ?? 10,
+      maxAttempts: o?.reconnect?.maxAttempts ?? 5
+    }, o?.onAudio && this.on("audio", o.onAudio), o?.onEvent && this.on("event", o.onEvent), o?.onError && this.on("error", o.onError), this.ready = new Promise((s, n) => {
+      this.resolveReady = s, this.rejectReady = n;
+    }), this.connect();
+  }
+  // ── Public send API ─────────────────────────────────────────────────────────
+  sendAudio(e) {
+    this.ws?.send(e);
+  }
+  sendText(e) {
+    this.sendControl({ type: "text", text: e });
+  }
+  activityStart() {
+    this.sendControl({ type: "activity_start" });
+  }
+  activityEnd() {
+    this.sendControl({ type: "activity_end" });
+  }
+  close() {
+    this.closedByUser = !0, this.sendControl({ type: "close" });
+    const e = this.ws;
+    e && (e.readyState === 0 || e.readyState === 1) && e.close(1e3);
+  }
+  // ── Subscription API ─────────────────────────────────────────────────────────
+  on(e, r) {
+    return this.listeners[e] || (this.listeners[e] = []), this.listeners[e].push(r), this;
+  }
+  off(e, r) {
+    return this.listeners[e] = (this.listeners[e] ?? []).filter((o) => o !== r), this;
+  }
+  // ── Internals ────────────────────────────────────────────────────────────────
+  emit(e, ...r) {
+    (this.listeners[e] ?? []).forEach((o) => {
+      try {
+        o(...r);
+      } catch (s) {
+        this.ctx.debug && console.warn("TenxGraphClient [realtime]: listener threw", s);
+      }
+    });
+  }
+  sendControl(e) {
+    this.ws?.send(JSON.stringify(e));
+  }
+  connect() {
+    const e = D(this.ctx, "/v1/graph/live");
+    this.ctx.debug && console.debug("TenxGraphClient [realtime]: connecting to", e);
+    const r = M(e, this.ctx);
+    try {
+      r.binaryType = "arraybuffer";
+    } catch {
+    }
+    this.ws = r, r.addEventListener("open", () => {
+      this.ws === r && (this.sendControl(this.init), this.readyResolved || (this.readyResolved = !0, this.resolveReady()), this.emit("open"));
+    }), r.addEventListener("message", (o) => {
+      this.ws === r && this.handleMessage(o.data);
+    }), r.addEventListener("close", (o) => {
+      if (this.ws !== r) return;
+      const s = o?.code ?? 1e3;
+      this.emit("close", s), this.maybeReconnect();
+    }), r.addEventListener("error", () => {
+      this.ws === r && (this.readyResolved || (this.readyResolved = !0, this.rejectReady(new Error("Realtime WebSocket connection failed"))));
+    });
+  }
+  handleMessage(e) {
+    const r = xe(e);
+    if (r) {
+      this.emit("audio", r, Ne);
+      return;
+    }
+    if (typeof e != "string") return;
+    let o;
+    try {
+      o = JSON.parse(e);
+    } catch {
+      this.ctx.debug && console.warn("TenxGraphClient [realtime]: bad JSON frame", e);
+      return;
+    }
+    o.type === "session_update" && (this.resumptionHandle = o.resumption_handle ?? this.resumptionHandle), o.type === "error" && o.fatal && (this.fatal = !0), this.emit("event", o), this.emit(o.type, o);
+  }
+  maybeReconnect() {
+    if (this.closedByUser || this.fatal || !this.reconnectCfg.enabled)
+      return;
+    if (this.reconnectAttempts >= this.reconnectCfg.maxAttempts) {
+      this.fatal = !0;
+      const o = {
+        type: "error",
+        code: "reconnect_failed",
+        message: `Realtime reconnect gave up after ${this.reconnectCfg.maxAttempts} attempt(s)`,
+        fatal: !0
+      };
+      this.emit("error", o), this.emit("event", o);
+      return;
+    }
+    this.reconnectAttempts += 1;
+    const e = this.reconnectAttempts, r = Math.min(this.reconnectCfg.baseDelay * 2 ** (e - 1), this.reconnectCfg.maxDelay) * 1e3;
+    this.emit("reconnecting", e), setTimeout(() => this.reconnect(), r);
+  }
+  reconnect() {
+    this.init = {
+      ...this.init,
+      thread_id: this.threadId,
+      ...this.resumptionHandle ? { resumption_handle: this.resumptionHandle } : {}
+    };
+    const e = () => {
+      this.reconnectAttempts = 0, this.emit("reconnected");
+    };
+    this.connect(), this.ws?.addEventListener("open", e, { once: !0 });
+  }
+}
+var L = /* @__PURE__ */ ((t) => (t.EPISODIC = "episodic", t.SEMANTIC = "semantic", t.PROCEDURAL = "procedural", t.ENTITY = "entity", t.RELATIONSHIP = "relationship", t.CUSTOM = "custom", t.DECLARATIVE = "declarative", t))(L || {});
+async function De(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Storing memory with type", e.memory_type);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/store/memories`, n = {
+      config: e.config || {},
+      options: e.options || {},
+      content: e.content,
+      memory_type: e.memory_type,
+      category: e.category,
+      metadata: e.metadata || {}
+    }, i = await fetch(s, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(n),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !i.ok)
+      throw console.warn(`TenxGraphClient: Store memory failed with HTTP ${i.status}`), await p(
+        i,
+        "Store memory request failed",
+        "/v1/memory",
+        "POST"
+      );
+    const a = await i.json();
+    return t.debug && console.info("TenxGraphClient: Memory stored successfully", a), a;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Store memory failed:", r), r;
+  }
+}
+var Me = /* @__PURE__ */ ((t) => (t.SIMILARITY = "similarity", t.TEMPORAL = "temporal", t.RELEVANCE = "relevance", t.HYBRID = "hybrid", t.GRAPH_TRAVERSAL = "graph_traversal", t))(Me || {}), Le = /* @__PURE__ */ ((t) => (t.COSINE = "cosine", t.EUCLIDEAN = "euclidean", t.DOT_PRODUCT = "dot_product", t.MANHATTAN = "manhattan", t))(Le || {});
+async function Fe(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Searching memories with query:", e.query);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/store/search`, n = {
+      config: e.config || {},
+      options: e.options || {},
+      query: e.query,
+      memory_type: e.memory_type || L.EPISODIC,
+      category: e.category || "",
+      limit: e.limit !== void 0 ? e.limit : 10,
+      score_threshold: e.score_threshold !== void 0 ? e.score_threshold : 0,
+      filters: e.filters || {},
+      retrieval_strategy: e.retrieval_strategy || "similarity",
+      distance_metric: e.distance_metric || "cosine",
+      max_tokens: e.max_tokens !== void 0 ? e.max_tokens : 4e3
+    }, i = await fetch(s, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(n),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !i.ok)
+      throw console.warn(`TenxGraphClient: Search memory failed with HTTP ${i.status}`), await p(
+        i,
+        "Search memory request failed",
+        "/v1/memory/search",
+        "POST"
+      );
+    const a = await i.json();
+    return t.debug && console.info("TenxGraphClient: Memory search successful", {
+      query: e.query,
+      results_count: a.data.results.length
+    }), a;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Search memory failed:", r), r;
+  }
+}
+async function He(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Fetching memory with ID:", e.memoryId);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/store/memories/${e.memoryId}`, n = {
+      config: e.config || {},
+      options: e.options || {}
+    }, i = await fetch(s, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(n),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !i.ok)
+      throw console.warn(`TenxGraphClient: Get memory failed with HTTP ${i.status}`), await p(
+        i,
+        "Get memory request failed",
+        "/v1/memory/{memory_id}",
+        "GET"
+      );
+    const a = await i.json();
+    return t.debug && console.info("TenxGraphClient: Memory fetched successfully", {
+      memory_id: e.memoryId,
+      content: a.data.memory.content.substring(0, 50)
+    }), a;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Get memory failed:", r), r;
+  }
+}
+async function Be(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Updating memory with ID:", e.memoryId);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/store/memories/${e.memoryId}`, n = {
+      config: e.config || {},
+      options: e.options || {},
+      content: e.content,
+      metadata: e.metadata || {}
+    };
+    t.debug && console.debug("TenxGraphClient: Request payload:", JSON.stringify(n, null, 2));
+    const i = await fetch(s, {
+      method: "PUT",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(n),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !i.ok)
+      throw console.warn(`TenxGraphClient: Update memory failed with HTTP ${i.status}`), await p(
+        i,
+        "Update memory request failed",
+        "/v1/memory/{memory_id}",
+        "PUT"
+      );
+    const a = await i.json();
+    return t.debug && console.info("TenxGraphClient: Memory updated successfully", {
+      memory_id: e.memoryId,
+      success: a.data.success
+    }), a;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Update memory failed:", r), r;
+  }
+}
+async function Je(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Deleting memory with ID:", e.memoryId);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/store/memories/${e.memoryId}`, n = {
+      config: e.config || {},
+      options: e.options || {}
+    };
+    t.debug && console.debug("TenxGraphClient: Delete request payload:", JSON.stringify(n, null, 2));
+    const i = await fetch(s, {
+      method: "DELETE",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(n),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !i.ok)
+      throw console.warn(`TenxGraphClient: Delete memory failed with HTTP ${i.status}`), await p(
+        i,
+        "Delete memory request failed",
+        "/v1/memory/{memory_id}",
+        "DELETE"
+      );
+    const a = await i.json();
+    return t.debug && console.info("TenxGraphClient: Memory deleted successfully", {
+      memory_id: e.memoryId,
+      success: a.data.success
+    }), a;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: Delete memory timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: Delete memory failed:", r), r);
+  }
+}
+async function We(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Fetching list of memories", {
+      limit: e.limit
+    });
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = `${t.baseUrl}/v1/store/memories/list`, n = {
+      config: e.config || {},
+      options: e.options || {},
+      limit: e.limit || 100
+    };
+    t.debug && console.debug(
+      "TenxGraphClient: List memories request payload:",
+      JSON.stringify(n, null, 2)
+    );
+    const i = await fetch(s, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(n),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !i.ok)
+      throw console.warn(`TenxGraphClient: List memories failed with HTTP ${i.status}`), await p(
+        i,
+        "List memories request failed",
+        "/v1/memory",
+        "GET"
+      );
+    const a = await i.json();
+    return t.debug && console.info("TenxGraphClient: Memories list fetched successfully", {
+      count: a.data.memories.length,
+      limit: e.limit
+    }), a;
+  } catch (r) {
+    throw r.name === "AbortError" ? (console.warn(`TenxGraphClient: List memories timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (t.debug && console.debug("TenxGraphClient: List memories failed:", r), r);
+  }
+}
+async function ze(t, e) {
+  try {
+    const r = `${t.baseUrl}/v1/store/memories/forget`, o = {};
+    e.config && (o.config = e.config), e.options && (o.options = e.options), e.memory_type && (o.memory_type = e.memory_type), e.category && (o.category = e.category), e.filters && (o.filters = e.filters), t.debug && console.log("[DEBUG] Forget memories request:", o);
+    const s = new AbortController();
+    let n;
+    t.timeout > 0 && (n = setTimeout(() => s.abort(), t.timeout));
+    const i = await fetch(r, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(o),
+      ...t.timeout > 0 && { signal: s.signal }
+    });
+    if (n && clearTimeout(n), !i.ok)
+      throw new Error(`Forget memories failed: ${i.status} ${i.statusText}`);
+    const a = await i.json();
+    return t.debug && console.log("[DEBUG] Forget memories response:", a), a;
+  } catch (r) {
+    throw r.name === "AbortError", r;
+  }
+}
+async function Ve(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Stopping graph execution for thread:", e.thread_id);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = await fetch(`${t.baseUrl}/v1/graph/stop`, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(e),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw console.warn(`TenxGraphClient: Stop graph failed with HTTP ${s.status}`), await p(
+        s,
+        "Stop graph execution failed",
+        "/v1/graph/stop",
+        "POST"
+      );
+    const n = await s.json();
+    return t.debug && console.info("TenxGraphClient: Graph execution stopped successfully", n), n;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Stop graph failed:", r), r.name === "AbortError" ? (console.warn(`TenxGraphClient: Stop graph timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: Stop graph failed:", r), r);
+  }
+}
+async function Ye(t, e) {
+  try {
+    t.debug && console.debug("TenxGraphClient: Fixing graph state for thread:", e.thread_id);
+    const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout), s = await fetch(`${t.baseUrl}/v1/graph/fix`, {
+      method: "POST",
+      headers: m(t, {
+        "Content-Type": "application/json",
+        accept: "application/json"
+      }),
+      ...f(t),
+      body: JSON.stringify(e),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw console.warn(`TenxGraphClient: Fix graph failed with HTTP ${s.status}`), await p(
+        s,
+        "Fix graph state failed",
+        "/v1/graph/fix",
+        "POST"
+      );
+    const n = await s.json();
+    return t.debug && console.info("TenxGraphClient: Graph state fixed successfully", {
+      removed_count: n.data.removed_count,
+      success: n.data.success
+    }), n;
+  } catch (r) {
+    throw t.debug && console.debug("TenxGraphClient: Fix graph failed:", r), r.name === "AbortError" ? (console.warn(`TenxGraphClient: Fix graph timeout after ${t.timeout}ms`), new Error(`Request timeout after ${t.timeout}ms`)) : (console.error("TenxGraphClient: Fix graph failed:", r), r);
+  }
+}
+async function Ke(t, e) {
+  const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout);
+  try {
+    const s = new FormData();
+    typeof File < "u" && e instanceof File ? s.append("file", e, e.name) : "data" in e && "filename" in e ? s.append("file", e.data, e.filename) : s.append("file", e, "upload");
+    const n = await fetch(`${t.baseUrl}/v1/files/upload`, {
+      method: "POST",
+      headers: m(t),
+      body: s,
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !n.ok)
+      throw await p(
+        n,
+        "File upload failed",
+        "/v1/files/upload",
+        "POST"
+      );
+    return await n.json();
+  } finally {
+    clearTimeout(o);
+  }
+}
+async function Ze(t, e) {
+  const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout);
+  try {
+    const s = await fetch(`${t.baseUrl}/v1/files/${encodeURIComponent(e)}`, {
+      method: "GET",
+      headers: m(t),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw await p(
+        s,
+        "File download failed",
+        `/v1/files/${e}`,
+        "GET"
+      );
+    return await s.blob();
+  } finally {
+    clearTimeout(o);
+  }
+}
+async function Qe(t, e) {
+  const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout);
+  try {
+    const s = await fetch(`${t.baseUrl}/v1/files/${encodeURIComponent(e)}/info`, {
+      method: "GET",
+      headers: m(t),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw await p(
+        s,
+        "File info request failed",
+        `/v1/files/${e}/info`,
+        "GET"
+      );
+    return await s.json();
+  } finally {
+    clearTimeout(o);
+  }
+}
+async function Xe(t, e) {
+  const r = new AbortController(), o = setTimeout(() => r.abort(), t.timeout);
+  try {
+    const s = await fetch(`${t.baseUrl}/v1/files/${encodeURIComponent(e)}/url`, {
+      method: "GET",
+      headers: m(t),
+      ...f(t),
+      signal: r.signal
+    });
+    if (clearTimeout(o), !s.ok)
+      throw await p(
+        s,
+        "File access URL request failed",
+        `/v1/files/${e}/url`,
+        "GET"
+      );
+    return await s.json();
+  } finally {
+    clearTimeout(o);
+  }
+}
+async function qe(t) {
+  const e = new AbortController(), r = setTimeout(() => e.abort(), t.timeout);
+  try {
+    const o = await fetch(`${t.baseUrl}/v1/config/multimodal`, {
+      method: "GET",
+      headers: m(t, {
+        accept: "application/json"
+      }),
+      ...f(t),
+      signal: e.signal
+    });
+    if (clearTimeout(r), !o.ok)
+      throw await p(
+        o,
+        "Multimodal config request failed",
+        "/v1/config/multimodal",
+        "GET"
+      );
+    return await o.json();
+  } finally {
+    clearTimeout(r);
+  }
+}
+function et(t) {
+  return typeof t == "object" && t !== null;
+}
+function tt(t, e, r) {
+  return et(t) ? {
+    search: t.search,
+    offset: t.offset,
+    limit: t.limit
+  } : {
+    search: t,
+    offset: e,
+    limit: r
+  };
+}
+function rt(t) {
+  return typeof t == "object" && t !== null;
+}
+function ot(t, e, r, o) {
+  return rt(e) ? {
+    threadId: t,
+    search: e.search,
+    offset: e.offset,
+    limit: e.limit
+  } : {
+    threadId: t,
+    search: e,
+    offset: r,
+    limit: o
+  };
+}
+class st {
+  constructor(e) {
+    this.baseUrl = e.baseUrl, this.authToken = e.authToken, this.auth = e.auth, this.headers = e.headers, this.credentials = e.credentials, this.timeout = e.timeout || 3e5, this.debug = e.debug || !1, this.webSocketImpl = e.webSocketImpl, this.toolExecutor = new z([]);
+  }
+  createContext() {
+    return {
+      baseUrl: this.baseUrl,
+      authToken: this.authToken,
+      auth: this.auth,
+      headers: this.headers,
+      credentials: this.credentials,
+      timeout: this.timeout,
+      debug: this.debug,
+      webSocketImpl: this.webSocketImpl
+    };
+  }
+  /**
+   * Register a tool for remote execution
+   */
+  registerTool(e) {
+    this.toolExecutor.registerTool(e), this.debug && console.debug(`TenxGraphClient: Registered remote tool handler '${e.name}'`);
+  }
+  /**
+   * Register only the client-side implementation of a remote tool.
+   * The trusted schema must be declared in the server's 10xgraph.json.
+   */
+  registerToolHandler(e, r) {
+    this.registerTool({ name: e, handler: r });
+  }
+  /**
+   * Ping the server to check connectivity
+   */
+  async ping() {
+    const e = this.createContext();
+    return ne(e);
+  }
+  /**
+   * Fetch the agent graph
+   */
+  async graph() {
+    const e = this.createContext();
+    return ie(e);
+  }
+  /**
+   * Fetch the tools exposed by the graph's tool nodes, grouped by node.
+   * Each tool is tagged with its source (local / mcp / remote).
+   */
+  async graphTools() {
+    const e = this.createContext();
+    return ae(e);
+  }
+  /**
+   * Fetch the reconstructed observability trace (spans, events, cost) for a
+   * thread. Returns the latest run by default, or a specific run when given.
+   */
+  async observability(e, r) {
+    const o = this.createContext();
+    return le(o, e, r);
+  }
+  /**
+   * Stop a running graph execution for a specific thread
+   * @param threadId - The ID of the thread to stop execution for
+   * @param config - Optional configuration for the stop operation
+   * @returns StopGraphResponse with the stop operation result
+   */
+  async stopGraph(e, r) {
+    const o = this.createContext();
+    return Ve(o, {
+      thread_id: e,
+      config: r
+    });
+  }
+  /**
+   * Fix graph state by removing messages with empty tool calls
+   * This is useful for cleaning up incomplete tool call messages that may have
+   * failed or been interrupted during execution.
+   *
+   * @param threadId - The ID of the thread to fix state for
+   * @param config - Optional configuration for the fix operation
+   * @returns FixGraphResponse with the fix operation result including removed_count
+   */
+  async fixGraph(e, r) {
+    const o = this.createContext();
+    return Ye(o, {
+      thread_id: e,
+      config: r
+    });
+  }
+  /**
+       * 
+  
+      /**
+       * Fetch the state schema of the agent
+       */
+  async graphStateSchema() {
+    const e = this.createContext();
+    return ce(e);
+  }
+  /**
+   * ***************** ALL THREAD APIS *****************
+   */
+  /**
+   * Fetch the state of a specific thread
+   * @param threadId - The ID of the thread to fetch state for
+   * @returns ThreadStateResponse containing the thread's current state
+   */
+  async threadState(e) {
+    const r = this.createContext();
+    return he(r, e);
+  }
+  /**
+   * Update the state of a specific thread (checkpoint)
+   * @param threadId - The ID of the thread to update
+   * @param config - Configuration map for the thread
+   * @param state - New AgentState for the thread
+   * @returns UpdateThreadStateResponse with the updated state
+   */
+  async updateThreadState(e, r, o) {
+    const s = this.createContext();
+    return de(s, e, {
+      config: r,
+      state: o
+    });
+  }
+  /**
+   * Clear the state of a specific thread (delete checkpoint)
+   * @param threadId - The ID of the thread to clear state for
+   * @returns ClearThreadStateResponse with the clear operation result
+   */
+  async clearThreadState(e) {
+    const r = this.createContext();
+    return ue(r, e);
+  }
+  /**
+   * Fetch details for a specific thread
+   * @param threadId - The ID of the thread to fetch
+   * @returns ThreadDetailsResponse containing thread details
+   */
+  async threadDetails(e) {
+    const r = this.createContext();
+    return pe(r, e);
+  }
+  async threads(e, r, o) {
+    const s = this.createContext(), n = tt(e, r, o);
+    return ye(s, n);
+  }
+  async threadMessages(e, r, o, s) {
+    const n = this.createContext(), i = ot(e, r, o, s);
+    return U(n, i);
+  }
+  /**
+   * Add messages to a specific thread checkpoint
+   * @param threadId - The ID of the thread to add messages to
+   * @param messages - Array of messages to add to the checkpoint
+   * @param config - Configuration map for the checkpoint
+   * @param metadata - Optional metadata for the checkpoint
+   * @returns AddCheckpointMessagesResponse containing the operation result
+   */
+  async addThreadMessages(e, r, o = {}, s) {
+    const n = this.createContext();
+    return me(n, {
+      threadId: e,
+      config: o,
+      messages: r,
+      metadata: s
+    });
+  }
+  /**
+   * Fetch a specific message from a thread by message ID
+   * @param threadId - The ID of the thread
+   * @param messageId - The ID of the message to fetch
+   * @returns ThreadMessageResponse containing the message and metadata
+   */
+  async singleMessage(e, r) {
+    const o = this.createContext();
+    return fe(o, {
+      threadId: e,
+      messageId: r
+    });
+  }
+  /**
+   * Delete a specific message from a thread
+   * @param threadId - The ID of the thread
+   * @param messageId - The ID of the message to delete
+   * @param config - Optional configuration map to send with the request body
+   * @returns DeleteThreadMessageResponse containing the deletion result
+   */
+  async deleteMessage(e, r, o) {
+    const s = this.createContext();
+    return ge(s, {
+      threadId: e,
+      messageId: r,
+      config: o
+    });
+  }
+  /**
+   * Delete a specific thread
+   * @param threadId - The ID of the thread to delete
+   * @param config - Optional configuration map to send with the request body
+   * @returns DeleteThreadResponse containing the deletion result
+   */
+  async deleteThread(e, r) {
+    const o = this.createContext();
+    return Te(o, {
+      threadId: e,
+      config: r
+    });
+  }
+  /**
+   * Invoke the agent graph with automatic tool execution loop
+   * @param messages - Array of messages to send
+   * @param options - Invoke options
+   * @returns InvokeResult with all messages and intermediate steps
+   */
+  async invoke(e, r) {
+    const o = {
+      ...this.createContext(),
+      toolExecutor: this.toolExecutor
+    }, s = {
+      messages: e.map((n) => this.serializeMessage(n)),
+      initial_state: r?.initial_state,
+      config: r?.config,
+      recursion_limit: r?.recursion_limit || 25,
+      response_granularity: r?.response_granularity || "full"
+    };
+    return Ce(o, s, r?.onPartialResult);
+  }
+  /**
+   * Stream invoke to the agent graph
+   * Returns an async iterable that yields stream chunks as they arrive
+   *
+   * @param messages - Array of messages to send
+   * @param options - Stream options
+   * @returns AsyncGenerator of StreamChunk objects
+   *
+   * @example
+   * ```ts
+   * const stream = client.streamInvoke([userMessage], {
+   *   initial_state: {},
+   *   response_granularity: 'low'
+   * });
+   *
+   * for await (const chunk of stream) {
+   *   if (chunk.event === 'message') {
+   *     console.log('Message:', chunk.message?.content);
+   *   } else if (chunk.event === 'updates') {
+   *     console.log('State updated:', chunk.state);
+   *   }
+   * }
+   * ```
+   */
+  stream(e, r) {
+    const o = {
+      ...this.createContext(),
+      toolExecutor: this.toolExecutor
+    }, s = {
+      messages: e.map((n) => this.serializeMessage(n)),
+      initial_state: r?.initial_state,
+      config: r?.config,
+      recursion_limit: r?.recursion_limit || 25,
+      response_granularity: r?.response_granularity || "low"
+    };
+    return Re(o, s);
+  }
+  /**
+   * Stream invoke via a persistent WebSocket connection.
+   *
+   * Identical API to ``stream()`` — same message types, same chunk format,
+   * same tool-execution loop — but uses a single WebSocket instead of one
+   * HTTP request per tool-call iteration.  Switch from ``stream()`` to
+   * ``wsStream()`` by changing one method name; everything else stays the
+   * same.
+   *
+   * The WebSocket stays open for the full lifecycle of the call (fresh run +
+   * any resume runs triggered by remote tool calls).  The server sends a
+   * ``{ event:"updates", data:{ status:"done" } }`` chunk after each run so
+   * the client knows when to send the next resume request.
+   *
+   * Auth: the bearer token is sent via the ``10xgraph-bearer`` WebSocket
+   * subprotocol (browser-safe; never placed in the URL), with the Authorization
+   * header also set on Node runtimes.
+   *
+   * @param messages - Array of messages to send
+   * @param options - Same options as ``stream()``
+   * @returns AsyncGenerator of StreamChunk objects
+   *
+   * @example
+   * ```ts
+   * const stream = client.wsStream([userMessage], {
+   *   config: { thread_id: 'my-thread' },
+   *   response_granularity: 'low',
+   * });
+   *
+   * for await (const chunk of stream) {
+   *   if (chunk.event === 'message') {
+   *     console.log('Message:', chunk.message?.content);
+   *   }
+   * }
+   * ```
+   */
+  wsStream(e, r) {
+    const o = {
+      ...this.createContext(),
+      toolExecutor: this.toolExecutor
+    }, s = {
+      messages: e.map((n) => this.serializeMessage(n)),
+      initial_state: r?.initial_state,
+      config: r?.config,
+      recursion_limit: r?.recursion_limit ?? 25,
+      response_granularity: r?.response_granularity ?? "low"
+    };
+    return Oe(o, s);
+  }
+  /**
+   * Open a realtime (audio-to-audio) session over ``/v1/graph/live``.
+   *
+   * Transport-only: send PCM16 input via ``session.sendAudio(...)`` and receive
+   * PCM16 output via ``session.on('audio', ...)``. Mic capture and audio playback
+   * are the caller's responsibility. The session auto-reconnects (with backoff)
+   * on an unexpected drop and resumes the same ``thread_id``.
+   *
+   * @example
+   * ```ts
+   * const session = client.realtime({ model: 'gemini-2.5-flash-live' });
+   * session.on('audio', (pcm) => speaker.write(pcm));
+   * session.on('output_transcript', (e) => console.log(e.text));
+   * await session.ready;
+   * session.sendAudio(micChunk);
+   * ```
+   */
+  realtime(e, r) {
+    const o = this.createContext();
+    return new Pe(o, e, r);
+  }
+  /**
+   * Store a memory in the agent's memory system
+   *
+   * @param request - Memory storage request parameters
+   * @returns Promise<StoreMemoryResponse> containing the memory_id
+   *
+   * @example
+   * ```ts
+   * const result = await client.storeMemory({
+   *   content: "User prefers dark mode",
+   *   memory_type: MemoryType.SEMANTIC,
+   *   category: "preferences",
+   *   metadata: { source: "user_settings" }
+   * });
+   * console.log('Memory stored with ID:', result.data.memory_id);
+   * ```
+   */
+  async storeMemory(e) {
+    const r = this.createContext();
+    return De(r, e);
+  }
+  /**
+   * Search for memories in the agent's memory system
+   *
+   * @param request - Memory search request parameters
+   * @returns Promise<SearchMemoryResponse> containing matching memories
+   *
+   * @example
+   * ```ts
+   * const results = await client.searchMemory({
+   *   query: "dark mode preferences",
+   *   memory_type: MemoryType.SEMANTIC,
+   *   limit: 5,
+   *   retrieval_strategy: RetrievalStrategy.SIMILARITY
+   * });
+   * results.data.results.forEach(result => {
+   *   console.log('Memory:', result.content, 'Score:', result.score);
+   * });
+   * ```
+   */
+  async searchMemory(e) {
+    const r = this.createContext();
+    return Fe(r, e);
+  }
+  /**
+   * Get a specific memory by ID
+   *
+   * @param memoryId - The ID of the memory to retrieve
+   * @param options - Optional config and options
+   * @returns Promise<GetMemoryResponse> containing the memory details
+   *
+   * @example
+   * ```ts
+   * const memory = await client.getMemory('mem-12345', {
+   *   config: { include_vector: true }
+   * });
+   * console.log('Memory:', memory.data.memory.content);
+   * console.log('Score:', memory.data.memory.score);
+   * ```
+   */
+  async getMemory(e, r) {
+    const o = this.createContext(), s = {
+      memoryId: e,
+      config: r?.config,
+      options: r?.options
+    };
+    return He(o, s);
+  }
+  /**
+   * Update an existing memory by ID
+   *
+   * @param memoryId - The ID of the memory to update
+   * @param content - The updated content for the memory
+   * @param options - Optional config, options, and metadata
+   * @returns Promise<UpdateMemoryResponse> containing success status and updated data
+   *
+   * @example
+   * ```ts
+   * const result = await client.updateMemory('mem-12345', 'Updated content', {
+   *   metadata: { tags: ['important', 'updated'] }
+   * });
+   * console.log('Update success:', result.data.success);
+   * ```
+   */
+  async updateMemory(e, r, o) {
+    const s = this.createContext(), n = {
+      memoryId: e,
+      content: r,
+      config: o?.config,
+      options: o?.options,
+      metadata: o?.metadata
+    };
+    return Be(s, n);
+  }
+  /**
+   * Delete a memory by ID
+   *
+   * @param memoryId - The ID of the memory to delete
+   * @param options - Optional config and options
+   * @returns Promise<DeleteMemoryResponse> containing success status and deletion confirmation
+   *
+   * @example
+   * ```ts
+   * const result = await client.deleteMemory('mem-12345', {
+   *   config: { soft_delete: true }
+   * });
+   * console.log('Delete success:', result.data.success);
+   * console.log('Deleted:', result.data.data);
+   * ```
+   */
+  async deleteMemory(e, r) {
+    const o = this.createContext(), s = {
+      memoryId: e,
+      config: r?.config,
+      options: r?.options
+    };
+    return Je(o, s);
+  }
+  /**
+   * List all memories with optional pagination
+   *
+   * @param options - Optional config, options, and limit
+   * @returns Promise<ListMemoriesResponse> containing array of memories
+   *
+   * @example
+   * ```ts
+   * const result = await client.listMemories({
+   *   limit: 50,
+   *   config: { include_vectors: false }
+   * });
+   * console.log('Found memories:', result.data.memories.length);
+   * result.data.memories.forEach(memory => {
+   *   console.log('Memory:', memory.content, 'Type:', memory.memory_type);
+   * });
+   * ```
+   */
+  async listMemories(e) {
+    const r = this.createContext(), o = {
+      config: e?.config,
+      options: e?.options,
+      limit: e?.limit
+    };
+    return We(r, o);
+  }
+  /**
+   * Forget (delete) memories based on filters and criteria
+   *
+   * @param options - Optional config, options, memory type, category, and filters
+   * @returns Promise<ForgetMemoriesResponse> containing success status
+   *
+   * @example
+   * ```ts
+   * // Forget all episodic memories in a category
+   * const result = await client.forgetMemories({
+   *   memory_type: MemoryType.EPISODIC,
+   *   category: 'temporary',
+   *   filters: { tag: 'delete-me' }
+   * });
+   * console.log('Forget success:', result.data.success);
+   * ```
+   */
+  async forgetMemories(e) {
+    const r = this.createContext(), o = {
+      config: e?.config,
+      options: e?.options,
+      memory_type: e?.memory_type,
+      category: e?.category,
+      filters: e?.filters
+    };
+    return ze(r, o);
+  }
+  // ------------------------------------------------------------------
+  // Files / Multimodal API
+  // ------------------------------------------------------------------
+  /**
+   * Upload a file (image, audio, document) to the server.
+   * Returns file metadata including file_id for use in multimodal messages.
+   *
+   * @param file - A File, Blob, or { data: Blob; filename: string } object
+   * @returns FileUploadResponse with file_id and metadata
+   *
+   * @example
+   * ```ts
+   * const result = await client.uploadFile(file);
+   * const msg = Message.withImage('Describe this', result.data.url);
+   * ```
+   */
+  async uploadFile(e) {
+    const r = this.createContext();
+    return Ke(r, e);
+  }
+  /**
+   * Download a file by its file_id. Returns raw Blob.
+   */
+  async getFile(e) {
+    const r = this.createContext();
+    return Ze(r, e);
+  }
+  /**
+   * Get metadata about a stored file.
+   */
+  async getFileInfo(e) {
+    const r = this.createContext();
+    return Qe(r, e);
+  }
+  /**
+   * Get the best access URL for a stored file.
+   * For cloud-backed media this will typically be a signed URL.
+   * For local or memory-backed media this may fall back to the API file route.
+   */
+  async getFileAccessUrl(e) {
+    const r = this.createContext();
+    return Xe(r, e);
+  }
+  /**
+   * Get the current multimodal configuration from the server.
+   */
+  async getMultimodalConfig() {
+    const e = this.createContext();
+    return qe(e);
+  }
+  /**
+   * Serialize a Message object for API transmission
+   * Converts Message class instances to plain objects
+   */
+  serializeMessage(e) {
+    const r = {
+      role: e.role,
+      content: this.cleanContent(e.content)
+    };
+    return e.message_id !== null && e.message_id !== void 0 ? r.message_id = String(e.message_id) : r.message_id = "0", e.tools_calls && (r.tools_calls = e.tools_calls), e.metadata && Object.keys(e.metadata).length > 0 && (r.metadata = e.metadata), r;
+  }
+  /**
+   * Clean content blocks by removing empty arrays and undefined values
+   * Server requires array of content blocks, not simplified string
+   */
+  cleanContent(e) {
+    return e.map((r) => {
+      const o = {};
+      for (const [s, n] of Object.entries(r))
+        Array.isArray(n) && n.length === 0 || n !== void 0 && (o[s] = n);
+      return o;
+    });
+  }
+}
+class nt {
+  constructor() {
+    this.current_node = "START", this.step = 0, this.is_running = !0, this.is_interrupted = !1, this.is_stopped_requested = !1;
+  }
+}
+class wt {
+  constructor(e = {}) {
+    this.context = [], this.context_summary = null, this.execution_meta = new nt(), Object.assign(this, e);
+  }
+}
+const bt = st, Ct = g;
+export {
+  bt as AgentFlowClient,
+  Ct as AgentFlowError,
+  wt as AgentState,
+  dt as AnnotationBlock,
+  it as AnnotationRef,
+  H as AudioBlock,
+  $ as AuthenticationError,
+  R as BadRequestError,
+  at as DataBlock,
+  Le as DistanceMetric,
+  J as DocumentBlock,
+  ut as ErrorBlock,
+  V as GraphError,
+  K as GraphRecursionError,
+  v as ImageBlock,
+  b as MediaRef,
+  L as MemoryType,
+  C as Message,
+  X as MetricsError,
+  Y as NodeError,
+  A as NotFoundError,
+  k as PermissionError,
+  yt as REALTIME_INPUT_SAMPLE_RATE,
+  Ne as REALTIME_OUTPUT_SAMPLE_RATE,
+  Pe as RealtimeSession,
+  ht as ReasoningBlock,
+  ct as RemoteToolCallBlock,
+  Me as RetrievalStrategy,
+  q as SchemaVersionError,
+  ee as SerializationError,
+  O as ServerError,
+  Z as StorageError,
+  x as StreamEventType,
+  st as TenxGraphClient,
+  g as TenxGraphError,
+  S as TextBlock,
+  mt as TokenUsages,
+  lt as ToolCallBlock,
+  z as ToolExecutor,
+  G as ToolResultBlock,
+  Q as TransientStorageError,
+  I as ValidationError,
+  B as VideoBlock,
+  ke as WS_BEARER_SUBPROTOCOL,
+  me as addThreadMessages,
+  pt as basicAuth,
+  ft as bearerAuth,
+  m as buildHeaders,
+  D as buildWsUrl,
+  Tt as checkpointMessages,
+  ue as clearThreadState,
+  p as createErrorFromResponse,
+  Je as deleteMemory,
+  Te as deleteThread,
+  ge as deleteThreadMessage,
+  Ye as fixGraph,
+  ze as forgetMemories,
+  Ze as getFile,
+  Xe as getFileAccessUrl,
+  Qe as getFileInfo,
+  He as getMemory,
+  qe as getMultimodalConfig,
+  f as getRequestCredentials,
+  ie as graph,
+  ae as graphTools,
+  gt as headerAuth,
+  Ce as invoke,
+  We as listMemories,
+  W as normalizeToolParameters,
+  le as observability,
+  M as openWebSocket,
+  te as parseErrorResponse,
+  ne as ping,
+  Ae as resolveBearerToken,
+  Fe as searchMemory,
+  P as serializeMessage,
+  ce as stateSchema,
+  Ve as stopGraph,
+  De as storeMemory,
+  Re as streamInvoke,
+  pe as threadDetails,
+  fe as threadMessage,
+  U as threadMessages,
+  he as threadState,
+  ye as threads,
+  Be as updateMemory,
+  de as updateThreadState,
+  Ke as uploadFile,
+  Oe as wsStreamInvoke
+};
+//# sourceMappingURL=index.js.map