@agents24/node 0.1.0

package/dist/index.js

@@ -0,0 +1,667 @@
+import { randomUUID } from 'crypto';
+import { createSseParser, parseRuntimeSsePayload, parseThreadSummarySsePayload } from '@agents24/client/protocol';
+export { CONTRACT_HASH, RUNTIME_PROTOCOL_VERSION, THREAD_SUMMARY_PROTOCOL_VERSION, compressionFromContextWindow, createContextWindowTracker, mergeContextWindow, mergeContextWindowUpdate, normalizeContextCompression, normalizeContextWindow, parseRuntimeEvent, parseRuntimeSsePayload, parseThreadSummarySsePayload, validateResponseBlock, validateRuntimeEvent, validateThreadSummaryEvent } from '@agents24/client/protocol';
+
+// src/http.ts
+
+// src/errors.ts
+var Agents24SDKError = class extends Error {
+  kind;
+  status;
+  details;
+  responseHeaders;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "Agents24SDKError";
+    this.kind = options.kind;
+    this.status = options.status;
+    this.details = options.details;
+    this.responseHeaders = options.responseHeaders;
+  }
+};
+
+// src/http.ts
+function required(value, name) {
+  const normalized = String(value || "").trim();
+  if (!normalized) throw new Agents24SDKError(`Agents24 requires ${name}.`, { kind: "protocol" });
+  return normalized;
+}
+function normalizeBaseUrl(value) {
+  try {
+    return new URL(required(value, "baseUrl")).toString().replace(/\/+$/, "");
+  } catch (cause) {
+    if (cause instanceof Agents24SDKError) throw cause;
+    throw new Agents24SDKError("Agents24 received an invalid baseUrl.", { kind: "protocol", cause });
+  }
+}
+async function errorDetails(response) {
+  const text = await response.text().catch(() => "");
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function detailMessage(details) {
+  if (typeof details === "string" && details.trim()) return details.trim();
+  if (!details || typeof details !== "object" || Array.isArray(details)) return void 0;
+  const detail = details.detail;
+  if (typeof detail === "string" && detail.trim()) return detail.trim();
+  if (detail && typeof detail === "object" && !Array.isArray(detail)) {
+    const message2 = detail.message;
+    if (typeof message2 === "string" && message2.trim()) return message2.trim();
+  }
+  const message = details.message;
+  return typeof message === "string" && message.trim() ? message.trim() : void 0;
+}
+function responseHeaders(response) {
+  const headers = {};
+  for (const name of ["dpop-nonce", "retry-after", "www-authenticate", "x-request-id"]) {
+    const value = response.headers.get(name);
+    if (value) headers[name] = value;
+  }
+  return headers;
+}
+async function assertOk(response) {
+  if (response.ok) return;
+  const details = await errorDetails(response);
+  throw new Agents24SDKError(detailMessage(details) || response.statusText || "Agents24 request failed.", {
+    kind: "http",
+    status: response.status,
+    details,
+    responseHeaders: responseHeaders(response)
+  });
+}
+var Agents24HttpClient = class {
+  base;
+  apiKey;
+  organizationId;
+  projectId;
+  fetchImpl;
+  constructor(options) {
+    if (typeof process === "undefined" || process.release?.name !== "node") {
+      throw new Agents24SDKError("@agents24/node is for trusted server runtimes only.", { kind: "protocol" });
+    }
+    this.base = normalizeBaseUrl(options.baseUrl);
+    this.apiKey = required(options.apiKey, "apiKey");
+    this.organizationId = required(options.organizationId, "organizationId");
+    this.projectId = required(options.projectId, "projectId");
+    if (typeof options.fetchImpl !== "function" && typeof fetch !== "function") {
+      throw new Agents24SDKError("No fetch implementation is available. Use Node 22 or 24.", { kind: "protocol" });
+    }
+    this.fetchImpl = options.fetchImpl || fetch;
+  }
+  url(requestPath, query) {
+    const url = new URL(`${this.base}${requestPath}`);
+    for (const [key, value] of Object.entries(query || {})) {
+      if (value === void 0 || value === null || value === "") continue;
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item !== void 0 && item !== null && item !== "") url.searchParams.append(key, String(item));
+        }
+      } else {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  jsonHeaders(extra, options, mutation = false) {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "X-Organization-ID": this.organizationId,
+      "X-Project-ID": this.projectId,
+      "X-SDK-Contract": "1",
+      ...mutation ? { "Idempotency-Key": options?.idempotencyKey || randomUUID() } : {},
+      ...options?.requestMetadata ? { "X-Request-Metadata": JSON.stringify(options.requestMetadata) } : {},
+      ...extra || {}
+    };
+  }
+  streamHeaders(extra, options, mutation = false) {
+    return this.jsonHeaders({ Accept: "text/event-stream", ...extra || {} }, options, mutation);
+  }
+  multipartHeaders(extra, options, mutation = false) {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "application/json",
+      "X-Organization-ID": this.organizationId,
+      "X-Project-ID": this.projectId,
+      "X-SDK-Contract": "1",
+      ...mutation ? { "Idempotency-Key": options?.idempotencyKey || randomUUID() } : {},
+      ...extra || {}
+    };
+  }
+  async requestJson(requestPath, config = {}) {
+    const query = { ...config.query || {} };
+    if (config.options?.dryRun !== void 0) query.dry_run = config.options.dryRun;
+    if (config.options?.validateOnly !== void 0) query.validate_only = config.options.validateOnly;
+    const response = await this.fetchOrThrow(this.url(requestPath, query), {
+      method: config.method || "GET",
+      headers: this.jsonHeaders(config.headers, config.options, Boolean(config.mutation)),
+      ...config.body === void 0 ? {} : { body: JSON.stringify(config.body) }
+    }, "Failed to connect to the Agents24 API.");
+    await assertOk(response);
+    return await response.json();
+  }
+  async fetchOrThrow(url, init, message) {
+    try {
+      return await this.fetchImpl(url, init);
+    } catch (cause) {
+      if (cause instanceof Agents24SDKError) throw cause;
+      throw new Agents24SDKError(message, { kind: "network", cause });
+    }
+  }
+};
+async function consumePayloads(response, onPayload, signal) {
+  if (!response.body) {
+    throw new Agents24SDKError("Stream response did not include a readable body.", { kind: "protocol" });
+  }
+  const reader = response.body.getReader();
+  const parser = createSseParser({ decoder: new TextDecoder(), onPayload, signal });
+  const abort = () => {
+    void reader.cancel(signal?.reason).catch(() => void 0);
+  };
+  if (signal?.aborted) return abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    while (!signal?.aborted) {
+      const { done, value } = await reader.read();
+      if (value) await parser.push(value);
+      if (done) break;
+    }
+    if (!signal?.aborted) await parser.finish();
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    reader.releaseLock();
+  }
+}
+async function consumeRuntimeEventStream(response, onEvent, signal) {
+  await consumePayloads(response, async (payload) => {
+    const event = parseRuntimeSsePayload(payload);
+    if (onEvent) await onEvent(event);
+  }, signal);
+}
+async function consumeThreadSummaryEventStream(response, onEvent, signal) {
+  await consumePayloads(response, async (payload) => {
+    await onEvent(parseThreadSummarySsePayload(payload));
+  }, signal);
+}
+
+// src/agents.ts
+var AgentsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(options = {}) {
+    return this.http.requestJson("/agents", { query: { status: options.status, skip: options.skip ?? 0, limit: options.limit ?? 20, view: options.view ?? "summary" } });
+  }
+  get(agentId) {
+    return this.http.requestJson(`/agents/${agentId}`);
+  }
+  create(request, options) {
+    return this.http.requestJson("/agents", { method: "POST", body: request, options, mutation: true });
+  }
+  update(agentId, request, options) {
+    return this.http.requestJson(`/agents/${agentId}`, { method: "PATCH", body: request, options, mutation: true });
+  }
+  updateGraph(agentId, graph, options) {
+    return this.http.requestJson(`/agents/${agentId}/graph`, { method: "PUT", body: graph, options, mutation: true });
+  }
+  delete(agentId, options) {
+    return this.http.requestJson(`/agents/${agentId}`, { method: "DELETE", options, mutation: true });
+  }
+  catalog() {
+    return this.http.requestJson("/agents/nodes/catalog");
+  }
+  schema(nodeTypes) {
+    return this.http.requestJson("/agents/nodes/schema", { method: "POST", body: { node_types: nodeTypes } });
+  }
+  validate(agentId) {
+    return this.http.requestJson(`/agents/${agentId}/validate`, { method: "POST", body: {} });
+  }
+  publish(agentId, options) {
+    return this.http.requestJson(`/agents/${agentId}/publish`, { method: "POST", body: {}, options, mutation: true });
+  }
+  startRun(agentId, payload, options) {
+    return this.http.requestJson(`/agents/${agentId}/run`, { method: "POST", body: payload, options, mutation: true });
+  }
+  async stream(agentId, payload, onEvent, mode, options = {}) {
+    const response = await this.http.fetchOrThrow(this.http.url(`/agents/${agentId}/stream`, { mode }), {
+      method: "POST",
+      headers: this.http.streamHeaders(),
+      body: JSON.stringify(payload),
+      signal: options.signal
+    }, "Failed to connect to the agent stream endpoint.");
+    await assertOk(response);
+    let runId = response.headers.get("X-Run-ID");
+    await consumeRuntimeEventStream(response, async (event) => {
+      runId ||= event.run_id;
+      if (onEvent) await onEvent(event);
+    }, options.signal);
+    return { threadId: response.headers.get("X-Thread-ID"), runId };
+  }
+  resumeRun(runId, payload, options) {
+    return this.http.requestJson(`/agents/runs/${runId}/resume`, { method: "POST", body: payload, options, mutation: true });
+  }
+  cancelRun(runId, options = {}) {
+    return this.http.requestJson(`/agents/runs/${runId}/cancel`, { method: "POST", body: { assistant_output_text: options.assistantOutputText }, mutation: true });
+  }
+  async uploadAttachments(agentId, options) {
+    const form = new FormData();
+    if (options.threadId) form.set("thread_id", options.threadId);
+    for (const file of options.files) form.append("files", file, file.name);
+    const response = await this.http.fetchOrThrow(this.http.url(`/agents/${agentId}/attachments/upload`), {
+      method: "POST",
+      headers: this.http.multipartHeaders(),
+      body: form
+    }, "Failed to connect to the agent attachment endpoint.");
+    await assertOk(response);
+    return await response.json();
+  }
+};
+
+// src/builders.ts
+function refId(ref) {
+  return typeof ref === "string" ? ref : ref.id;
+}
+function refs(values) {
+  return [...new Set((values || []).map(refId).filter(Boolean))];
+}
+function graphNode(id, type, x, y, config = {}) {
+  return { id, type, position: { x, y }, config };
+}
+function toolsetAttachments(options) {
+  const seen = /* @__PURE__ */ new Set();
+  return (options.toolsetAttachments || []).flatMap((attachment) => {
+    const id = refId(attachment.toolset);
+    if (!id || seen.has(id)) return [];
+    seen.add(id);
+    const policy = attachment.versionPolicy || { mode: "latest" };
+    return [{
+      toolset_id: id,
+      loading_mode: attachment.loadingMode || "static",
+      version_policy: policy.mode === "pinned" ? { mode: "pinned", version_id: policy.versionId } : { mode: "latest" }
+    }];
+  });
+}
+var AgentDefinitionBuilder = class {
+  constructor(agents, options) {
+    this.agents = agents;
+    this.options = options;
+  }
+  agents;
+  options;
+  toGraph() {
+    const agentConfig = {
+      instructions: this.options.instructions || "",
+      tools: refs(this.options.tools),
+      toolset_attachments: toolsetAttachments(this.options),
+      input_sources: [{ id: "workflow-text", value_ref: { namespace: "workflow_input", key: "text", label: "Workflow input / Text" } }]
+    };
+    if (this.options.model) agentConfig.model_id = refId(this.options.model);
+    return {
+      spec_version: "4.0",
+      graph_type: "agent",
+      workflow_contract: { inputs: [] },
+      state_contract: { variables: [] },
+      nodes: [
+        graphNode("start", "start", 0, 0),
+        graphNode("agent", "agent", 260, 0, agentConfig),
+        graphNode("end", "end", 520, 0, {
+          output_schema: {
+            name: "workflow_result",
+            mode: "simple",
+            schema: { type: "object", additionalProperties: false, properties: { response: { type: "string" } }, required: ["response"] }
+          },
+          output_bindings: [{ json_pointer: "/response", value_ref: { namespace: "node_output", node_id: "agent", key: "output_text", label: "Agent response" } }]
+        })
+      ],
+      edges: [
+        { id: "start-agent", source: "start", target: "agent", type: "control" },
+        { id: "agent-end", source: "agent", target: "end", type: "control" }
+      ]
+    };
+  }
+  toCreateRequest() {
+    const knowledge = refs(this.options.knowledge);
+    return {
+      name: this.options.name,
+      description: this.options.description ?? null,
+      graph_definition: this.toGraph(),
+      memory_config: {
+        ...this.options.memory || {},
+        ...knowledge.length ? { long_term_enabled: true, long_term_index_id: knowledge[0], knowledge_refs: knowledge } : {}
+      },
+      execution_constraints: this.options.execution || {}
+    };
+  }
+  create(options) {
+    return this.agents.create(this.toCreateRequest(), options);
+  }
+};
+var GraphBuilder = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  node(type, config = {}, options = {}) {
+    const id = options.id || `${type}_${this.nodes.size + 1}`;
+    if (this.nodes.has(id)) throw new Error(`Duplicate graph node id: ${id}`);
+    const value = graphNode(id, type, options.x ?? this.nodes.size * 260, options.y ?? 0, config);
+    if (options.label) value.label = options.label;
+    this.nodes.set(id, value);
+    return value;
+  }
+  connect(source, target, options = {}) {
+    const sourceId = typeof source === "string" ? source : source.id;
+    const targetId = typeof target === "string" ? target : target.id;
+    if (!this.nodes.has(sourceId)) throw new Error(`Unknown source node id: ${sourceId}`);
+    if (!this.nodes.has(targetId)) throw new Error(`Unknown target node id: ${targetId}`);
+    this.edges.push({
+      id: options.id || `${sourceId}-${targetId}`,
+      source: sourceId,
+      target: targetId,
+      type: "control",
+      source_handle: options.sourceHandle,
+      target_handle: options.targetHandle
+    });
+    return this;
+  }
+  toGraph() {
+    return {
+      spec_version: "4.0",
+      graph_type: "agent",
+      workflow_contract: { inputs: [] },
+      state_contract: { variables: [] },
+      nodes: [...this.nodes.values()],
+      edges: [...this.edges]
+    };
+  }
+};
+
+// src/client-runtime-admin.ts
+var ClientDeploymentsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  create(request, options) {
+    return this.http.requestJson("/client-runtime/deployments", {
+      method: "POST",
+      body: request,
+      options,
+      mutation: true
+    });
+  }
+  get(deploymentId) {
+    return this.http.requestJson(`/client-runtime/deployments/${deploymentId}`);
+  }
+  update(deploymentId, request, options) {
+    return this.http.requestJson(`/client-runtime/deployments/${deploymentId}`, {
+      method: "PATCH",
+      body: request,
+      options,
+      mutation: true
+    });
+  }
+  promote(deploymentId, request, options) {
+    return this.http.requestJson(`/client-runtime/deployments/${deploymentId}/promote`, {
+      method: "POST",
+      body: request,
+      options,
+      mutation: true
+    });
+  }
+  revoke(deploymentId, options) {
+    return this.http.requestJson(`/client-runtime/deployments/${deploymentId}`, {
+      method: "DELETE",
+      options,
+      mutation: true
+    });
+  }
+};
+var ClientSessionsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  createBackendSession(deploymentId, request, options) {
+    return this.http.requestJson(
+      `/client-runtime/deployments/${deploymentId}/session-tokens`,
+      {
+        method: "POST",
+        body: request,
+        options,
+        mutation: true,
+        headers: options?.dpopProof ? { DPoP: options.dpopProof } : void 0
+      }
+    );
+  }
+};
+
+// src/embed.ts
+var EmbedNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async streamAgent(agentId, payload, onEvent, options = {}) {
+    return this.stream(`/public/embed/agents/${agentId}/chat/stream`, payload, onEvent, options);
+  }
+  async attachAgentRun(agentId, runId, payload, onEvent, options = {}) {
+    return this.stream(`/public/embed/agents/${agentId}/runs/${runId}/stream`, payload, onEvent, options);
+  }
+  async stream(path, payload, onEvent, options) {
+    const response = await this.http.fetchOrThrow(this.http.url(path), {
+      method: "POST",
+      headers: this.http.streamHeaders(void 0, options, true),
+      body: JSON.stringify(payload),
+      signal: options.signal
+    }, "Failed to connect to the embedded-agent stream endpoint.");
+    await assertOk(response);
+    let runId = response.headers.get("X-Run-ID");
+    await consumeRuntimeEventStream(response, async (event) => {
+      runId ||= event.run_id;
+      if (onEvent) await onEvent(event);
+    }, options.signal);
+    return { threadId: response.headers.get("X-Thread-ID"), runId };
+  }
+  resumeAgentRun(agentId, runId, payload, options) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/runs/${runId}/resume`, { method: "POST", body: payload, options, mutation: true });
+  }
+  startAgentRunMcpAuth(agentId, runId, serverId, payload, options) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/runs/${runId}/mcp/servers/${serverId}/auth/start`, { method: "POST", body: payload, options, mutation: true });
+  }
+  getRuntimeBootstrap(agentId) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/runtime/bootstrap`);
+  }
+  listAgentThreads(agentId, options) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/threads`, { query: {
+      external_user_id: options.externalUserId,
+      external_session_id: options.externalSessionId,
+      skip: options.skip ?? 0,
+      limit: options.limit ?? 20
+    } });
+  }
+  listAgentThreadsMulti(options) {
+    return this.http.requestJson("/public/embed/threads/query", { method: "POST", body: options });
+  }
+  async subscribeAgentThreadEvents(agentId, options, onEvent) {
+    const response = await this.http.fetchOrThrow(this.http.url(`/public/embed/agents/${agentId}/threads/events`, {
+      external_user_id: options.externalUserId,
+      external_session_id: options.externalSessionId,
+      cursor: options.cursor
+    }), { method: "GET", headers: this.http.streamHeaders(), signal: options.signal }, "Failed to connect to the embedded-agent thread event endpoint.");
+    await assertOk(response);
+    await consumeThreadSummaryEventStream(response, onEvent, options.signal);
+  }
+  async subscribeAgentThreadEventsMulti(options, onEvent) {
+    const response = await this.http.fetchOrThrow(this.http.url("/public/embed/threads/events", {
+      agent_ids: options.agentIds,
+      external_user_id: options.externalUserId,
+      external_session_id: options.externalSessionId,
+      cursor: options.cursor
+    }), { method: "GET", headers: this.http.streamHeaders(), signal: options.signal }, "Failed to connect to the embedded-agent thread event endpoint.");
+    await assertOk(response);
+    await consumeThreadSummaryEventStream(response, onEvent, options.signal);
+  }
+  getAgentThread(agentId, threadId, options) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/threads/${threadId}`, { query: {
+      external_user_id: options.externalUserId,
+      external_session_id: options.externalSessionId,
+      before_turn_index: options.beforeTurnIndex,
+      limit: options.limit,
+      include_run_events: options.includeRunEvents,
+      include_subthreads: options.includeSubthreads,
+      subthread_depth: options.subthreadDepth,
+      subthread_turn_limit: options.subthreadTurnLimit,
+      subthread_child_limit: options.subthreadChildLimit
+    } });
+  }
+  deleteAgentThread(agentId, threadId, options) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/threads/${threadId}`, { method: "DELETE", query: {
+      external_user_id: options.externalUserId,
+      external_session_id: options.externalSessionId
+    }, mutation: true });
+  }
+  getAgentRunContext(agentId, runId, options) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/runs/${runId}/context`, { query: {
+      external_user_id: options.externalUserId,
+      external_session_id: options.externalSessionId
+    } });
+  }
+  cancelAgentRun(agentId, runId, options) {
+    return this.http.requestJson(`/public/embed/agents/${agentId}/runs/${runId}/cancel`, { method: "POST", query: {
+      external_user_id: options.externalUserId,
+      external_session_id: options.externalSessionId
+    }, body: {}, mutation: true });
+  }
+  async uploadAgentAttachments(agentId, options) {
+    const form = new FormData();
+    form.set("external_user_id", options.externalUserId);
+    if (options.externalSessionId) form.set("external_session_id", options.externalSessionId);
+    if (options.threadId) form.set("thread_id", options.threadId);
+    for (const file of options.files) form.append("files", file, file.name);
+    const response = await this.http.fetchOrThrow(this.http.url(`/public/embed/agents/${agentId}/attachments/upload`), {
+      method: "POST",
+      headers: this.http.multipartHeaders(void 0, { idempotencyKey: options.idempotencyKey }, true),
+      body: form
+    }, "Failed to connect to the embedded-agent attachment endpoint.");
+    await assertOk(response);
+    return await response.json();
+  }
+};
+
+// src/runs.ts
+var RunsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  get(runId, options = {}) {
+    return this.http.requestJson(`/agents/runs/${runId}`, { query: { include_tree: options.includeTree } });
+  }
+  getTree(runId) {
+    return this.http.requestJson(`/agents/runs/${runId}/tree`);
+  }
+  getEvents(runId, options = {}) {
+    return this.http.requestJson(`/agents/runs/${runId}/events`, { query: { after_sequence: options.afterSequence, limit: options.limit } });
+  }
+  getContext(runId) {
+    return this.http.requestJson(`/agents/runs/${runId}/context`);
+  }
+  async getTrace(runId) {
+    const run = await this.get(runId);
+    const tree = await this.getTree(runId);
+    const events = await this.getEvents(runId);
+    const context = await this.getContext(runId);
+    return { run, tree, events, context };
+  }
+};
+
+// src/client.ts
+var Agents24 = class {
+  agents;
+  embed;
+  runs;
+  clientDeployments;
+  clientSessions;
+  constructor(options) {
+    const http = new Agents24HttpClient(options);
+    this.agents = new AgentsNamespace(http);
+    this.embed = new EmbedNamespace(http);
+    this.runs = new RunsNamespace(http);
+    this.clientDeployments = new ClientDeploymentsNamespace(http);
+    this.clientSessions = new ClientSessionsNamespace(http);
+  }
+  agent(options) {
+    return new AgentDefinitionBuilder(this.agents, options);
+  }
+  graph() {
+    return new GraphBuilder();
+  }
+};
+
+// src/generated/manifest.ts
+var SDK_OPERATION_IDS = [
+  "agents.cancel_run",
+  "agents.catalog",
+  "agents.create",
+  "agents.delete",
+  "agents.get",
+  "agents.list",
+  "agents.publish",
+  "agents.resume_run",
+  "agents.schema",
+  "agents.start_run",
+  "agents.stream",
+  "agents.update",
+  "agents.update_graph",
+  "agents.upload_attachments",
+  "agents.validate",
+  "client.attachments.upload",
+  "client.bootstrap",
+  "client.chat.stream",
+  "client.deployments.create",
+  "client.deployments.get",
+  "client.deployments.promote",
+  "client.deployments.revoke",
+  "client.deployments.update",
+  "client.hitl.resume",
+  "client.jwks",
+  "client.mcp.redeem",
+  "client.mcp.start",
+  "client.runs.attach",
+  "client.runs.cancel",
+  "client.sessions.anonymous",
+  "client.sessions.backendExchange",
+  "client.sessions.refresh",
+  "client.sessions.revoke",
+  "client.threads.delete",
+  "client.threads.events",
+  "client.threads.get",
+  "client.threads.list",
+  "embed.attach_agent_run",
+  "embed.cancel_agent_run",
+  "embed.delete_agent_thread",
+  "embed.get_agent_run_context",
+  "embed.get_agent_thread",
+  "embed.get_runtime_bootstrap",
+  "embed.list_agent_threads",
+  "embed.list_agent_threads_multi",
+  "embed.resume_agent_run",
+  "embed.start_agent_run_mcp_auth",
+  "embed.stream_agent",
+  "embed.stream_agent_thread_events",
+  "embed.stream_agent_thread_events_multi",
+  "embed.upload_agent_attachments",
+  "runs.get",
+  "runs.get_context",
+  "runs.get_events",
+  "runs.get_tree"
+];
+
+export { AgentDefinitionBuilder, Agents24, Agents24SDKError as Agents24NodeError, Agents24SDKError, GraphBuilder, SDK_OPERATION_IDS };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map