@trillboards/api-client 2.2.1 → 3.2.1

package/dist/index.mjs

@@ -1,5 +1,8 @@
-import { __require } from './chunk-EIB4SNHX.mjs';
-export { generatedTypes } from './chunk-EIB4SNHX.mjs';
+import { __require } from './chunk-JLSS2URG.mjs';
+export { generatedTypes } from './chunk-JLSS2URG.mjs';
+import { createParser } from 'eventsource-parser';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { createHmac, timingSafeEqual } from 'crypto';
 
 // src/error.ts
@@ -72,7 +75,7 @@ var TrillboardsError = class _TrillboardsError extends Error {
 };
 
 // src/version.ts
-var VERSION = "1.2.0";
+var VERSION = "3.2.1";
 
 // src/http.ts
 var PUBLIC_PATHS = ["/v1/errors", "/v1/changelog", "/api/discover", "/v1/health"];
@@ -121,8 +124,15 @@ var HttpClient = class {
   constructor(config) {
     this.config = config;
   }
-  async request(method, path, options) {
-    const url = this.buildUrl(path, options?.params);
+  async request(method, path2, options) {
+    const response = await this.requestResponse(method, path2, options);
+    if (response.status === 204) return void 0;
+    const json = await this.readJson(response);
+    if (!response.ok) throw TrillboardsError.fromResponse(json, response);
+    return json;
+  }
+  async requestResponse(method, path2, options) {
+    const url = this.buildUrl(path2, options?.params);
     const headers = {
       "Content-Type": "application/json",
       "X-Trillboards-Client": `typescript-sdk/${VERSION}`,
@@ -130,7 +140,7 @@ var HttpClient = class {
       ...options?.headers ?? {}
     };
     const callerSuppliedAuth = Object.keys(options?.headers ?? {}).some((h) => h.toLowerCase() === "authorization");
-    const isPublic = PUBLIC_PATHS.some((prefix) => path.startsWith(prefix));
+    const isPublic = PUBLIC_PATHS.some((prefix) => path2.startsWith(prefix));
     if (!isPublic && this.config.apiKey && !callerSuppliedAuth) {
       headers["Authorization"] = `Bearer ${this.config.apiKey}`;
     }
@@ -144,13 +154,12 @@ var HttpClient = class {
     if (options?.body !== void 0 && options.body !== null) {
       fetchOptions.body = JSON.stringify(options.body);
     }
-    const response = await fetch(url, fetchOptions);
-    if (response.status === 204) {
-      return void 0;
-    }
-    let json;
+    fetchOptions.signal = options?.signal;
+    return fetch(url, fetchOptions);
+  }
+  async readJson(response) {
     try {
-      json = await response.json();
+      return await response.json();
     } catch {
       throw new TrillboardsError({
         type: "api_error",
@@ -159,13 +168,27 @@ var HttpClient = class {
         statusCode: response.status
       });
     }
-    if (!response.ok) {
-      throw TrillboardsError.fromResponse(json, response);
+  }
+  /** Open one authenticated live tail. The native endpoint has no replay cursor. */
+  async openStream(path2, options) {
+    const response = await this.requestResponse("GET", path2, {
+      ...options,
+      headers: { Accept: "text/event-stream", ...options?.headers }
+    });
+    if (!response.ok) throw TrillboardsError.fromResponse(await this.readJson(response), response);
+    if (!/^text\/event-stream(?:;|$)/i.test(response.headers.get("content-type") || "") || !response.body) {
+      await response.body?.cancel();
+      throw new TrillboardsError({
+        type: "api_error",
+        code: "invalid_response",
+        message: "Expected a text/event-stream response with a body.",
+        statusCode: response.status
+      });
     }
-    return json;
+    return response;
   }
-  get(path, opts) {
-    return this.request("GET", path, { params: opts?.params });
+  get(path2, opts) {
+    return this.request("GET", path2, { params: opts?.params });
   }
   /**
    * POST / PUT / PATCH / DELETE auto-retry on 429 + 5xx + network TypeError
@@ -178,20 +201,20 @@ var HttpClient = class {
    * of POST vs DELETE is enforced server-side via Idempotency-Key headers,
    * which the caller can attach via `opts.headers`.
    */
-  post(path, body, opts) {
-    return retryWithBackoff(() => this.request("POST", path, { body, headers: opts?.headers }), opts?.retry);
+  post(path2, body, opts) {
+    return retryWithBackoff(() => this.request("POST", path2, { body, headers: opts?.headers }), opts?.retry);
   }
-  put(path, body, opts) {
-    return retryWithBackoff(() => this.request("PUT", path, { body, headers: opts?.headers }), opts?.retry);
+  put(path2, body, opts) {
+    return retryWithBackoff(() => this.request("PUT", path2, { body, headers: opts?.headers }), opts?.retry);
   }
-  patch(path, body, opts) {
-    return retryWithBackoff(() => this.request("PATCH", path, { body, headers: opts?.headers }), opts?.retry);
+  patch(path2, body, opts) {
+    return retryWithBackoff(() => this.request("PATCH", path2, { body, headers: opts?.headers }), opts?.retry);
   }
-  delete(path, opts) {
-    return retryWithBackoff(() => this.request("DELETE", path, { headers: opts?.headers }), opts?.retry);
+  delete(path2, opts) {
+    return retryWithBackoff(() => this.request("DELETE", path2, { headers: opts?.headers }), opts?.retry);
   }
-  buildUrl(path, params) {
-    const base = `${this.config.baseUrl}${path}`;
+  buildUrl(path2, params) {
+    const base = `${this.config.baseUrl}${path2}`;
     if (!params || Object.keys(params).length === 0) {
       return base;
     }
@@ -413,6 +436,63 @@ var AudienceClient = class {
     return this.http.get("/v1/partner/audience/stats", { params });
   }
 };
+async function* readEventStream(http, path2, params, options) {
+  const controller = new AbortController();
+  const abort = () => controller.abort(options.signal?.reason);
+  if (options.signal?.aborted) abort();
+  else options.signal?.addEventListener("abort", abort, { once: true });
+  let reader;
+  try {
+    const response = await http.openStream(path2, { params, signal: controller.signal });
+    reader = response.body.getReader();
+    const decoder = new TextDecoder(), events = [];
+    let retry;
+    const parser = createParser({
+      onRetry: (value) => {
+        retry = value;
+      },
+      onEvent: (frame) => {
+        let data;
+        try {
+          data = JSON.parse(frame.data);
+        } catch {
+          throw new TrillboardsError({
+            type: "api_error",
+            code: "invalid_response",
+            message: "Expected JSON data in an SSE event.",
+            statusCode: response.status
+          });
+        }
+        events.push({
+          event: frame.event || "message",
+          data,
+          ...frame.id === void 0 ? {} : { id: frame.id },
+          ...retry === void 0 ? {} : { retry }
+        });
+        retry = void 0;
+      }
+    });
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      parser.feed(decoder.decode(chunk.value, { stream: true }));
+      while (events.length) {
+        if (controller.signal.aborted) throw controller.signal.reason;
+        yield events.shift();
+      }
+    }
+    parser.feed(decoder.decode());
+    while (events.length) yield events.shift();
+  } finally {
+    options.signal?.removeEventListener("abort", abort);
+    controller.abort();
+    try {
+      await reader?.cancel();
+    } catch {
+    }
+    reader?.releaseLock();
+  }
+}
 
 // src/resources/data.ts
 var DataClient = class {
@@ -420,13 +500,29 @@ var DataClient = class {
     this.http = http;
   }
   /** Get venue intelligence data for a screen. */
-  async getVenueIntelligence(screenId) {
-    return this.http.get(`/v1/partner/venue/${screenId}`);
+  getVenueIntelligence(screenId) {
+    return this.http.get("/v1/partner/venue/" + encodeURIComponent(screenId));
   }
   /** Get API usage summary. */
-  async getUsage(params) {
+  getUsage(params) {
     return this.http.get("/v1/partner/usage", { params });
   }
+  listScreens(query = {}) {
+    return this.http.get("/v1/data/screens", { params: query });
+  }
+  getHistory(screenId, query = {}) {
+    return this.http.get("/v1/data/screens/" + encodeURIComponent(screenId) + "/history", { params: query });
+  }
+  getAudience(screenId) {
+    return this.http.get("/v1/data/screens/" + encodeURIComponent(screenId) + "/audience");
+  }
+  query(body) {
+    return this.http.post("/v1/data/query", body);
+  }
+  /** One live tail; reconnect explicitly and recover history through bounded reads. */
+  stream(query = {}, options = {}) {
+    return readEventStream(this.http, "/v1/data/stream", query, options);
+  }
 };
 
 // src/resources/billing.ts
@@ -434,6 +530,19 @@ var BillingClient = class {
   constructor(http) {
     this.http = http;
   }
+  setup(body) {
+    return this.http.post("/v1/partner/billing/setup", body);
+  }
+  createCreditCheckout(body, options) {
+    return this.http.post("/v1/partner/billing/credits/checkout", body, { headers: { "Idempotency-Key": options.idempotencyKey } });
+  }
+  purchaseCredits(body, options) {
+    return this.http.post("/v1/partner/billing/credits", body, { headers: { "Idempotency-Key": options.idempotencyKey } });
+  }
+  /** Read the committed shared credit ledger after Stripe payment completes. */
+  getUsageSummary() {
+    return this.http.get("/v1/partner/billing/usage-summary");
+  }
   /** Get current billing info (plan, credits, usage). */
   async get() {
     return this.http.get("/v1/partner/billing");
@@ -476,6 +585,135 @@ var RoutesClient = class {
   }
 };
 
+// src/resources/creativeExperiments.ts
+var BASE2 = "/v1/partner/creative-experiments";
+var path = (id) => `${BASE2}/${encodeURIComponent(id)}`;
+var CreativeExperimentsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  create(body) {
+    return this.http.post(BASE2, body);
+  }
+  configureBrand(id, body) {
+    return this.http.post(path(id) + "/brand", body);
+  }
+  importCreative(id, body) {
+    return this.http.post(path(id) + "/creatives/import", body);
+  }
+  get(id) {
+    return this.http.get(path(id));
+  }
+  registerVariants(id, body) {
+    return this.http.post(path(id) + "/variants", body);
+  }
+  updatePolicy(id, body) {
+    return this.http.put(path(id) + "/policy", body);
+  }
+  getRewards(id, query) {
+    return this.http.get(path(id) + "/rewards", { params: query });
+  }
+  generate(id, body) {
+    return this.http.post(path(id) + "/creatives/generate", body);
+  }
+  review(id, body) {
+    return this.http.post(path(id) + "/creatives/review", body);
+  }
+  stop(id, body) {
+    return this.http.post(path(id) + "/stop", body);
+  }
+};
+var McpToolError = class extends Error {
+  constructor(tool, result) {
+    super("Native MCP tool failed: " + tool);
+    this.tool = tool;
+    this.result = result;
+    this.name = "McpToolError";
+  }
+};
+var MediaBuysClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  connection() {
+    if (!this.connecting) {
+      const client = new Client({ name: "trillboards-typescript", version: VERSION });
+      const transport = new StreamableHTTPClientTransport(new URL(this.config.baseUrl + "/mcp"), {
+        requestInit: { headers: {
+          Authorization: "Bearer " + this.config.apiKey,
+          "X-Trillboards-Client": "typescript-sdk/" + VERSION,
+          "User-Agent": "trillboards-typescript/" + VERSION,
+          ...this.config.version ? { "Trillboards-Version": this.config.version } : {}
+        } }
+      });
+      this.client = client;
+      this.transport = transport;
+      this.connecting = client.connect(transport).then(() => client).catch(async (error) => {
+        await client.close();
+        this.client = void 0;
+        this.transport = void 0;
+        this.connecting = void 0;
+        throw error;
+      });
+    }
+    return this.connecting;
+  }
+  async call(name, args) {
+    const client = await this.connection();
+    const result = await client.callTool({ name, arguments: args });
+    if (result.isError) throw new McpToolError(name, result);
+    if (result.structuredContent) return result.structuredContent;
+    for (const block of result.content) {
+      if (block.type !== "text") continue;
+      try {
+        return JSON.parse(block.text);
+      } catch {
+      }
+    }
+    throw new McpToolError(name, result);
+  }
+  getProducts(args = {}) {
+    return this.call("get_products", args);
+  }
+  listAccounts(args = {}) {
+    return this.call("list_accounts", args);
+  }
+  syncAccounts(args) {
+    return this.call("sync_accounts", args);
+  }
+  create(args) {
+    return this.call("create_media_buy", args);
+  }
+  list(args = {}) {
+    return this.call("get_media_buys", args);
+  }
+  update(args) {
+    return this.call("update_media_buy", args);
+  }
+  getDelivery(args) {
+    return this.call("get_media_buy_delivery", args);
+  }
+  syncCreatives(args) {
+    return this.call("sync_creatives", args);
+  }
+  discoverInventory(args = {}) {
+    return this.call("discover_inventory", args);
+  }
+  /** Release MCP streams and terminate an optional server session. */
+  async close() {
+    await this.connecting?.catch(() => void 0);
+    const client = this.client, transport = this.transport;
+    this.client = void 0;
+    this.transport = void 0;
+    this.connecting = void 0;
+    try {
+      if (transport?.sessionId) await transport.terminateSession();
+    } finally {
+      await client?.close();
+    }
+  }
+};
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.trillboards.com";
 var TrillboardsClient = class {
@@ -503,6 +741,8 @@ var TrillboardsClient = class {
     this.errors = new ErrorsClient(this._http);
     this.billing = new BillingClient(this._http);
     this.routes = new RoutesClient(this._http);
+    this.creativeExperiments = new CreativeExperimentsClient(this._http);
+    this.mediaBuys = new MediaBuysClient({ apiKey: options.apiKey, baseUrl, version: options.version });
   }
 };
 var DEFAULT_TOLERANCE_SECONDS = 300;
@@ -798,6 +1038,6 @@ var Webhooks = {
   verifyAdcpWebhook
 };
 
-export { ADCP_WEBHOOK_SIGNING_TAG, AnalyticsClient, AudienceClient, BillingClient, DataClient, DevicesClient, EarningsClient, ErrorsClient, FleetClient, ImpressionsClient, RoutesClient, ScreensClient, TrillboardsClient, TrillboardsError, VERSION, Webhooks, WebhooksClient, constructEvent, constructEventLegacy, parseSignatureHeader, retryWithBackoff, verifyAdcpWebhook };
+export { ADCP_WEBHOOK_SIGNING_TAG, AnalyticsClient, AudienceClient, BillingClient, CreativeExperimentsClient, DataClient, DevicesClient, EarningsClient, ErrorsClient, FleetClient, ImpressionsClient, McpToolError, MediaBuysClient, RoutesClient, ScreensClient, TrillboardsClient, TrillboardsError, VERSION, Webhooks, WebhooksClient, constructEvent, constructEventLegacy, parseSignatureHeader, retryWithBackoff, verifyAdcpWebhook };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map