@trillboards/api-client 3.1.15 → 3.2.5

package/dist/index.mjs

@@ -1,5 +1,8 @@
-import { __require } from './chunk-X2AIWEHJ.mjs';
-export { generatedTypes } from './chunk-X2AIWEHJ.mjs';
+import { __require } from './chunk-A5ESPUCN.mjs';
+export { generatedTypes } from './chunk-A5ESPUCN.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 = "3.1.15";
+var VERSION = "3.2.5";
 
 // src/http.ts
 var PUBLIC_PATHS = ["/v1/errors", "/v1/changelog", "/api/discover", "/v1/health"];
@@ -122,6 +125,13 @@ var HttpClient = class {
     this.config = config;
   }
   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",
@@ -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,10 +168,24 @@ 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(path2, opts) {
     return this.request("GET", path2, { params: opts?.params });
@@ -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");
@@ -514,6 +623,96 @@ var CreativeExperimentsClient = class {
     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";
@@ -543,6 +742,7 @@ var TrillboardsClient = class {
     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;
@@ -838,6 +1038,6 @@ var Webhooks = {
   verifyAdcpWebhook
 };
 
-export { ADCP_WEBHOOK_SIGNING_TAG, AnalyticsClient, AudienceClient, BillingClient, CreativeExperimentsClient, 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