@gravity-ai/api 1.1.4 → 1.1.5

package/dist/opentui.mjs

@@ -0,0 +1,316 @@
+import {
+  __require
+} from "./chunk-EBO3CZXG.mjs";
+
+// opentui.ts
+import { execFile } from "child_process";
+function openUrl(url) {
+  if (!url) return;
+  try {
+    let child;
+    if (process.platform === "darwin") {
+      child = execFile("open", [url]);
+    } else if (process.platform === "win32") {
+      child = execFile("rundll32", ["url.dll,FileProtocolHandler", url]);
+    } else {
+      child = execFile("xdg-open", [url]);
+    }
+    child.on("error", () => {
+    });
+  } catch {
+  }
+}
+function fireImpression(impUrl) {
+  try {
+    fetch(impUrl).catch(() => {
+    });
+  } catch {
+  }
+}
+function gravityAdTracking(options) {
+  const {
+    renderer,
+    input,
+    panel,
+    clickTargets = [],
+    onImpression,
+    onClick,
+    onHoverIn,
+    onHoverOut
+  } = options;
+  let activeAd = null;
+  let activeUrl = "";
+  let hovered = false;
+  let _impressionFired = false;
+  function setHover(next) {
+    if (!activeUrl) return;
+    if (hovered === next) return;
+    hovered = next;
+    if (next && activeAd) {
+      if (onHoverIn) {
+        onHoverIn(activeAd);
+      } else {
+        input.blur();
+        renderer.setCursorStyle({ cursor: "pointer", style: "block", blinking: false });
+        renderer.setMousePointer("pointer");
+      }
+    } else {
+      if (onHoverOut) {
+        onHoverOut();
+      } else {
+        renderer.setCursorStyle({ cursor: "default", style: "block", blinking: false });
+        renderer.setMousePointer("default");
+        input.focus();
+      }
+    }
+    renderer.requestRender();
+  }
+  function handleClick() {
+    if (!activeUrl || !activeAd) return;
+    onClick?.(activeAd);
+    openUrl(activeUrl);
+    renderer.requestRender();
+  }
+  function wireMouse(target) {
+    target.onMouseOver = () => setHover(true);
+    target.onMouseOut = () => setHover(false);
+    target.onMouseMove = () => setHover(true);
+    target.onMouseDown = () => handleClick();
+  }
+  wireMouse(panel);
+  for (const target of clickTargets) {
+    wireMouse(target);
+  }
+  function clear() {
+    if (hovered) {
+      if (onHoverOut) {
+        onHoverOut();
+      } else {
+        renderer.setCursorStyle({ cursor: "default", style: "block", blinking: false });
+        renderer.setMousePointer("default");
+        input.focus();
+      }
+    }
+    activeAd = null;
+    activeUrl = "";
+    hovered = false;
+    _impressionFired = false;
+    panel.visible = false;
+  }
+  function setAd(ad) {
+    if (!ad) {
+      clear();
+      return;
+    }
+    if (hovered) {
+      if (onHoverOut) {
+        onHoverOut();
+      } else {
+        renderer.setCursorStyle({ cursor: "default", style: "block", blinking: false });
+        renderer.setMousePointer("default");
+        input.focus();
+      }
+    }
+    activeAd = ad;
+    activeUrl = ad.clickUrl || ad.url || "";
+    hovered = false;
+    _impressionFired = false;
+    panel.visible = true;
+    if (ad.impUrl) {
+      fireImpression(ad.impUrl);
+      _impressionFired = true;
+      onImpression?.(ad);
+    }
+  }
+  return {
+    setAd,
+    clear,
+    get ad() {
+      return activeAd;
+    },
+    get impressionFired() {
+      return _impressionFired;
+    }
+  };
+}
+var CARD_DEFAULTS = {
+  panel: {
+    borderStyle: "single",
+    borderColor: "#3F3F46",
+    backgroundColor: "#09090B"
+  },
+  hoverPanel: {
+    borderColor: "#71717A",
+    backgroundColor: "#18181B"
+  },
+  text: { fg: "#A1A1AA" },
+  cta: { fg: "#2563EB" },
+  label: { fg: "#71717A" }
+};
+function wrapLineCount(text, width) {
+  const value = (text || "").trim();
+  if (!value) return 0;
+  const segments = value.split("\n");
+  let totalLines = 0;
+  for (const segment of segments) {
+    const trimmed = segment.trim();
+    if (!trimmed) {
+      totalLines++;
+      continue;
+    }
+    const words = trimmed.split(/\s+/);
+    let lines = 1;
+    let current = 0;
+    for (const word of words) {
+      if (current === 0) {
+        current = word.length;
+      } else if (current + 1 + word.length <= width) {
+        current += 1 + word.length;
+      } else {
+        lines++;
+        current = word.length;
+      }
+    }
+    totalLines += lines;
+  }
+  return totalLines;
+}
+function createGravityAdCard(options) {
+  const {
+    renderer,
+    input,
+    variant = "card",
+    onImpression,
+    onClick
+  } = options;
+  const panelStyle = { ...CARD_DEFAULTS.panel, ...options.panel };
+  const hoverStyle = { ...CARD_DEFAULTS.hoverPanel, ...options.hoverPanel };
+  const textStyle = { ...CARD_DEFAULTS.text, ...options.text };
+  const ctaStyle = { ...CARD_DEFAULTS.cta, ...options.cta };
+  const labelStyle = { ...CARD_DEFAULTS.label, ...options.label };
+  let BoxRenderable;
+  let TextRenderable;
+  try {
+    const core = __require("@opentui/core");
+    BoxRenderable = core.BoxRenderable;
+    TextRenderable = core.TextRenderable;
+  } catch {
+    throw new Error(
+      "createGravityAdCard() requires @opentui/core as a peer dependency. Install it with: bun add @opentui/core"
+    );
+  }
+  const isCard = variant === "card";
+  const adPanel = new BoxRenderable(renderer, {
+    width: "100%",
+    visible: false,
+    flexDirection: "column",
+    ...isCard ? {
+      border: true,
+      borderStyle: panelStyle.borderStyle,
+      borderColor: panelStyle.borderColor,
+      backgroundColor: panelStyle.backgroundColor,
+      paddingLeft: 2,
+      paddingRight: 2
+    } : {
+      border: false,
+      paddingLeft: 1
+    }
+  });
+  const adLabel = new TextRenderable(renderer, {
+    position: "absolute",
+    top: 0,
+    right: isCard ? 2 : 0,
+    wrapMode: "none",
+    content: "",
+    fg: labelStyle.fg
+  });
+  const adText = new TextRenderable(renderer, {
+    width: "100%",
+    wrapMode: "word",
+    content: "",
+    fg: textStyle.fg
+  });
+  const adCta = new TextRenderable(renderer, {
+    wrapMode: "none",
+    content: "",
+    fg: ctaStyle.fg
+  });
+  adPanel.add(adLabel);
+  adPanel.add(adText);
+  adPanel.add(adCta);
+  function applyHover(hovered) {
+    if (!isCard) return;
+    if (hovered) {
+      adPanel.borderColor = hoverStyle.borderColor;
+      adPanel.backgroundColor = hoverStyle.backgroundColor;
+    } else {
+      adPanel.borderColor = panelStyle.borderColor;
+      adPanel.backgroundColor = panelStyle.backgroundColor;
+    }
+  }
+  const tracking = gravityAdTracking({
+    renderer,
+    input,
+    panel: adPanel,
+    clickTargets: [adLabel, adText, adCta],
+    onImpression,
+    onClick,
+    onHoverIn: () => {
+      applyHover(true);
+      input.blur();
+      renderer.setCursorStyle({ cursor: "pointer", style: "block", blinking: false });
+      renderer.setMousePointer("pointer");
+    },
+    onHoverOut: () => {
+      applyHover(false);
+      renderer.setCursorStyle({ cursor: "default", style: "block", blinking: false });
+      renderer.setMousePointer("default");
+      input.focus();
+    }
+  });
+  function clear() {
+    tracking.clear();
+    adLabel.content = "";
+    adText.content = "";
+    adCta.content = "";
+    applyHover(false);
+  }
+  function showAd(ad) {
+    if (!ad) {
+      clear();
+      return;
+    }
+    const title = ad.title || ad.brandName || "Sponsored";
+    const body = ad.adText || "";
+    const cta = ad.cta || "";
+    adLabel.content = "Ad";
+    adText.content = body ? `${title}
+${body}` : title;
+    adCta.content = cta;
+    const contentWidth = Math.max(24, (process.stdout.columns || 80) - 10);
+    const titleLines = wrapLineCount(title, contentWidth);
+    const bodyLines = wrapLineCount(body, contentWidth);
+    const ctaLines = cta ? 1 : 0;
+    const borderPad = isCard ? 2 : 0;
+    adText.height = titleLines + bodyLines;
+    adPanel.height = titleLines + bodyLines + ctaLines + borderPad;
+    applyHover(false);
+    tracking.setAd(ad);
+    renderer.requestRender();
+  }
+  return {
+    panel: adPanel,
+    showAd,
+    clear,
+    elements: {
+      text: adText,
+      cta: adCta,
+      label: adLabel
+    },
+    tracking
+  };
+}
+export {
+  createGravityAdCard,
+  gravityAdTracking
+};

package/dist/types-DYbti_CZ.d.mts

@@ -0,0 +1,249 @@
+/**
+ * Role type for conversation messages
+ * @description Indicates whether a message is from the user or the AI assistant
+ */
+type Role = 'user' | 'assistant';
+/**
+ * Gender type for user targeting
+ * @description Used for demographic targeting of advertisements
+ */
+type Gender = 'male' | 'female' | 'other';
+/**
+ * Placement positions for ad rendering
+ * @description Specifies where ads should appear relative to the AI response
+ */
+type Placement = 'above_response' | 'below_response' | 'inline_response' | 'left_response' | 'right_response';
+/**
+ * Individual ad placement specification
+ * @description Defines a single ad slot with its position and optional tracking ID
+ * @example
+ * ```typescript
+ * const placement: PlacementObject = {
+ *   placement: 'below_response',
+ *   placement_id: 'sidebar-1'
+ * };
+ * ```
+ */
+interface PlacementObject {
+    /** Position where the ad should appear (required) */
+    placement: Placement;
+    /** Tracking ID for this specific ad slot (required) */
+    placement_id: string;
+}
+/**
+ * Represents a single message in a conversation
+ * @description Used to provide conversation context for contextual ad targeting
+ * @example
+ * ```typescript
+ * const message: MessageObject = {
+ *   role: 'user',
+ *   content: 'I need help finding a new laptop.'
+ * };
+ * ```
+ */
+interface MessageObject {
+    /** The role of the message sender - either 'user' or 'assistant' */
+    role: Role;
+    /** The text content of the message */
+    content: string;
+}
+/**
+ * Device and location information for ad targeting
+ * @description Provides device-level context for better ad relevance and compliance
+ * @example
+ * ```typescript
+ * const device: DeviceObject = {
+ *   ip: '192.168.1.1',
+ *   country: 'US',
+ *   ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)...',
+ *   os: 'macOS'
+ * };
+ * ```
+ */
+interface DeviceObject {
+    /** User's IP address for geo-targeting (required) */
+    ip: string;
+    /** Browser user-agent string (optional for non-web publishers like IDEs, CLIs, mobile apps) */
+    ua?: string;
+    /** ISO 3166-1 alpha-2 country code (e.g., 'US', 'GB', 'DE') */
+    country?: string;
+    /** Operating system name (e.g., 'macOS', 'Windows', 'iOS', 'Android') */
+    os?: string;
+    /** Identifier for Advertisers (mobile advertising ID) */
+    ifa?: string;
+    /** Additional device properties (timezone, locale, browser, device_type, screen dimensions, etc.) */
+    [key: string]: string | number | boolean | undefined;
+}
+/**
+ * User profile information for ad targeting
+ * @description Demographic and interest data for personalized ad delivery
+ * @example
+ * ```typescript
+ * const user: UserObject = {
+ *   uid: 'user-123',
+ *   gender: 'male',
+ *   age: '25-34',
+ *   keywords: 'technology,programming,gaming'
+ * };
+ * ```
+ */
+interface UserObject {
+    /** Unique user identifier for improving ad relevance */
+    uid?: string;
+    /** User's gender for demographic targeting */
+    gender?: Gender;
+    /** Age range string (e.g., '18-24', '25-34', '35-44', '45-54', '55-64', '65+') */
+    age?: string;
+    /** Comma-separated keywords representing user interests */
+    keywords?: string;
+    /** Additional user properties (email, subscription_tier, user_interests, company_size, etc.) */
+    [key: string]: string | string[] | number | boolean | Gender | undefined;
+}
+/**
+ * @deprecated Use `Gravity.getAds()` or `gravityAds()` instead, which accept
+ * standard request objects and auto-extract context from `gravityContext()`.
+ */
+interface AdParams {
+    /** Array of conversation messages for contextual targeting (required) */
+    messages: MessageObject[];
+    /** Session identifier for ad relevance (required) */
+    sessionId: string;
+    /** Ad placement specifications (required). Array of 1-10 placements. */
+    placements: PlacementObject[];
+    /** Unique user identifier */
+    userId?: string;
+    /** Device and location information */
+    device?: DeviceObject;
+    /** User demographic and interest data */
+    user?: UserObject;
+    /** Topics to exclude from ad matching (e.g., ['politics', 'religion']) */
+    excludedTopics?: string[];
+    /** Minimum relevancy score threshold (0-1). Higher = more relevant but fewer ads */
+    relevancy?: number | null;
+    /** Returns a test ad when true (no billing, for integration testing) */
+    testAd?: boolean;
+    /**
+     * Additional custom fields for publisher-specific targeting
+     * @description Any additional key-value pairs will be passed to the API
+     */
+    [key: string]: unknown;
+}
+/**
+ * Single ad object in responses.
+ * @description Contains ad creative and tracking data. Returned as a flat array from v1 API.
+ * @example
+ * ```typescript
+ * const ad: Ad = {
+ *   adText: 'Check out our amazing laptops!',
+ *   title: 'Dell XPS 15',
+ *   cta: 'Shop Now',
+ *   brandName: 'Dell',
+ *   url: 'https://dell.com/xps',
+ *   impUrl: 'https://tracking.example.com/imp?id=123',
+ *   clickUrl: 'https://tracking.example.com/click?id=123'
+ * };
+ * ```
+ */
+interface Ad {
+    /** The advertisement copy text */
+    adText: string;
+    /** Ad title */
+    title?: string;
+    /** Call-to-action text (e.g., 'Learn More', 'Shop Now') */
+    cta?: string;
+    /** Brand/advertiser name */
+    brandName?: string;
+    /** Landing page URL */
+    url?: string;
+    /** Favicon URL */
+    favicon?: string;
+    /** Impression tracking URL - fire this when ad is displayed */
+    impUrl?: string;
+    /** Click-through tracking URL - use this as href for ad clicks */
+    clickUrl?: string;
+}
+/**
+ * Error response structure from the Gravity API
+ * @description Returned when the API encounters an error processing the request
+ */
+interface ApiErrorResponse {
+    /** Error code or type identifier */
+    error: string;
+    /** Human-readable error description */
+    message?: string;
+    /** HTTP status code */
+    statusCode?: number;
+}
+/**
+ * Overrides passed to `gravityContext()`.
+ * `sessionId` and `user.userId` are required; everything else is auto-detected.
+ */
+interface GravityContextOverrides {
+    /** Your chat/conversation session ID (required) */
+    sessionId: string;
+    /** User info — `userId` is required */
+    user: {
+        userId: string;
+    } & Record<string, unknown>;
+    /** Device field overrides (timezone, locale, etc.) */
+    device?: Record<string, unknown>;
+}
+/** The context object returned by `gravityContext()` and sent in the request body. */
+interface GravityContext {
+    sessionId: string;
+    user: {
+        id: string;
+    } & Record<string, unknown>;
+    device: Record<string, unknown>;
+}
+/** Options for `gravityAds()`. */
+interface GravityAdsOptions {
+    /** Gravity API key. Defaults to `process.env.GRAVITY_API_KEY`. */
+    apiKey?: string;
+    /** Gravity ad endpoint URL. Defaults to production. */
+    gravityApi?: string;
+    /** Abort after this many ms. Default: `3000`. */
+    timeoutMs?: number;
+    /** Minimum relevancy threshold (0-1). Default: `0.2`. */
+    relevancy?: number;
+    /**
+     * Serve real ads when `true`. Defaults to `false` (test ads, no billing).
+     * Pass `production: true` when you're ready to go live.
+     */
+    production?: boolean;
+    /** Topics to exclude from ad matching. */
+    excludedTopics?: string[];
+}
+/** Result returned by `gravityAds()`. Never throws. */
+interface GravityAdsResult {
+    /** Matched ads (empty array on failure or no-fill). */
+    ads: Ad[];
+    /** HTTP status from the Gravity API. `0` = network error or missing API key. */
+    status: number;
+    /** Round-trip time in ms (string for easy logging). */
+    elapsed: string;
+    /** The full request body sent to Gravity (useful for debugging). */
+    requestBody: Record<string, unknown> | null;
+    /** Error message, only present on failure. */
+    error?: string;
+}
+/**
+ * Minimal server request shape that `gravityAds()` can read.
+ * Compatible with Express, Fastify, Node http (with body-parser), Next.js, etc.
+ */
+interface IncomingAdRequest {
+    body?: {
+        gravity_context?: GravityContext;
+        [key: string]: unknown;
+    };
+    headers?: Record<string, string | string[] | undefined>;
+    socket?: {
+        remoteAddress?: string;
+    };
+    connection?: {
+        remoteAddress?: string;
+    };
+    ip?: string;
+}
+
+export type { AdParams as A, DeviceObject as D, GravityAdsOptions as G, IncomingAdRequest as I, MessageObject as M, PlacementObject as P, Role as R, UserObject as U, GravityAdsResult as a, GravityContextOverrides as b, GravityContext as c, Ad as d, ApiErrorResponse as e, Placement as f, Gender as g };