@the_ro_show/agent-ads-sdk 0.17.0 → 0.18.0

package/dist/index.js

@@ -21,10 +21,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   APIRequestError: () => APIRequestError,
+  AdvertiserClient: () => AdvertiserClient,
   AttentionMarketClient: () => AttentionMarketClient,
   AttentionMarketError: () => AttentionMarketError,
+  DeveloperClient: () => DeveloperClient,
   MockAttentionMarketClient: () => MockAttentionMarketClient,
   NetworkError: () => NetworkError,
+  SessionClient: () => SessionClient,
   TimeoutError: () => TimeoutError,
   buildTaxonomy: () => buildTaxonomy,
   createImpressionEvent: () => createImpressionEvent,
@@ -98,6 +101,10 @@ var HTTPClient = class {
   constructor(config) {
     this.config = config;
   }
+  /** Expose the API key so sub-clients can re-use it in different headers */
+  get apiKey() {
+    return this.config.apiKey;
+  }
   async request(method, path, options = {}) {
     const url = `${this.config.baseUrl}${path}`;
     let lastError;
@@ -125,21 +132,26 @@ var HTTPClient = class {
         "Content-Type": "application/json",
         ...options.headers
       };
-      if (this.config.supabaseAnonKey) {
-        headers["Authorization"] = `Bearer ${this.config.supabaseAnonKey}`;
-      }
-      if (this.config.apiKey) {
-        headers["X-AM-API-Key"] = this.config.apiKey;
+      if (!options.skipDefaultAuth) {
+        if (this.config.supabaseAnonKey) {
+          headers["Authorization"] = `Bearer ${this.config.supabaseAnonKey}`;
+        }
+        if (this.config.apiKey) {
+          headers["X-AM-API-Key"] = this.config.apiKey;
+        }
       }
       if (options.idempotencyKey) {
         headers["Idempotency-Key"] = options.idempotencyKey;
       }
-      const response = await fetch(url, {
+      const fetchInit = {
         method,
         headers,
-        body: options.body ? JSON.stringify(options.body) : void 0,
         signal: controller.signal
-      });
+      };
+      if (options.body) {
+        fetchInit.body = JSON.stringify(options.body);
+      }
+      const response = await fetch(url, fetchInit);
       clearTimeout(timeoutId);
       if (!response.ok) {
         const errorBody = await response.json().catch(() => ({
@@ -493,6 +505,432 @@ function calculateMessageCount(conversationHistory) {
   return (conversationHistory?.length || 0) + 1;
 }
 
+// src/session-client.ts
+var SessionClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Initiate a new capability session.
+   *
+   * @example
+   * ```typescript
+   * const session = await client.sessions.initiate({
+   *   capability_type: 'code_review',
+   *   config: { language: 'typescript' }
+   * });
+   * console.log(session.session_id);
+   * ```
+   */
+  async initiate(request) {
+    return this.http.request(
+      "POST",
+      "/capability-session",
+      { body: { action: "initiate", ...request } }
+    );
+  }
+  /**
+   * Send a message within an existing capability session.
+   *
+   * @example
+   * ```typescript
+   * const response = await client.sessions.sendMessage({
+   *   session_id: 'sess_abc123',
+   *   message: 'Review this function for bugs'
+   * });
+   * console.log(response.response);
+   * ```
+   */
+  async sendMessage(request) {
+    if (!request.session_id) {
+      throw new Error("session_id is required");
+    }
+    if (!request.message) {
+      throw new Error("message is required");
+    }
+    return this.http.request(
+      "POST",
+      "/capability-session",
+      { body: { action: "message", ...request } }
+    );
+  }
+  /**
+   * End a capability session.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.sessions.end({
+   *   session_id: 'sess_abc123',
+   *   reason: 'task_completed'
+   * });
+   * ```
+   */
+  async end(request) {
+    if (!request.session_id) {
+      throw new Error("session_id is required");
+    }
+    return this.http.request(
+      "POST",
+      "/capability-session",
+      { body: { action: "end", ...request } }
+    );
+  }
+  /**
+   * Connect a GitHub repository to the capability session.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.sessions.connectGitHub({
+   *   session_id: 'sess_abc123',
+   *   repository: 'owner/repo',
+   *   branch: 'main'
+   * });
+   * ```
+   */
+  async connectGitHub(request) {
+    if (!request.session_id) {
+      throw new Error("session_id is required");
+    }
+    if (!request.repository) {
+      throw new Error("repository is required");
+    }
+    return this.http.request(
+      "POST",
+      "/capability-session",
+      { body: { action: "connect-github", ...request } }
+    );
+  }
+};
+
+// src/developer-client.ts
+var DeveloperClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Log in as a developer. Returns a session token for subsequent calls.
+   * No API key auth needed for this endpoint.
+   *
+   * @example
+   * ```typescript
+   * const session = await client.developer.login({
+   *   email: 'dev@example.com',
+   *   password: 'secret'
+   * });
+   * console.log(session.session_token);
+   * ```
+   */
+  async login(request) {
+    if (!request.email) {
+      throw new Error("email is required");
+    }
+    if (!request.password) {
+      throw new Error("password is required");
+    }
+    return this.http.request(
+      "POST",
+      "/developer-login",
+      { body: request, skipDefaultAuth: true }
+    );
+  }
+  /**
+   * Get developer account data using a session token.
+   * No default API key auth — uses session token in body.
+   *
+   * @example
+   * ```typescript
+   * const data = await client.developer.getData('session_token_here');
+   * console.log(data.agent_name);
+   * ```
+   */
+  async getData(sessionToken) {
+    if (!sessionToken) {
+      throw new Error("sessionToken is required");
+    }
+    return this.http.request(
+      "POST",
+      "/developer-data",
+      { body: { session_token: sessionToken }, skipDefaultAuth: true }
+    );
+  }
+  /**
+   * Get developer earnings. Uses X-API-Key header (not X-AM-API-Key).
+   *
+   * @example
+   * ```typescript
+   * const earnings = await client.developer.getEarnings();
+   * console.log(earnings.balances.available);
+   * ```
+   */
+  async getEarnings() {
+    const apiKey = this.http.apiKey;
+    if (!apiKey) {
+      throw new Error("API key is required for getEarnings()");
+    }
+    return this.http.request(
+      "GET",
+      "/developer-earnings",
+      {
+        skipDefaultAuth: true,
+        headers: { "X-API-Key": apiKey }
+      }
+    );
+  }
+  /**
+   * Get developer stats. Uses standard X-AM-API-Key auth.
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.developer.getStats({ period: '30d' });
+   * console.log(stats.impressions, stats.clicks);
+   * ```
+   */
+  async getStats(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.period) {
+      queryParams.append("period", params.period);
+    }
+    const qs = queryParams.toString();
+    const url = `/developer-stats${qs ? "?" + qs : ""}`;
+    return this.http.request("GET", url);
+  }
+  /**
+   * Get developer analytics. Uses session token in body (no default auth).
+   *
+   * @example
+   * ```typescript
+   * const analytics = await client.developer.getAnalytics('session_token', {
+   *   start_date: '2026-01-01',
+   *   group_by: 'week'
+   * });
+   * ```
+   */
+  async getAnalytics(sessionToken, params) {
+    if (!sessionToken) {
+      throw new Error("sessionToken is required");
+    }
+    return this.http.request(
+      "POST",
+      "/developer-analytics",
+      {
+        body: { session_token: sessionToken, ...params },
+        skipDefaultAuth: true
+      }
+    );
+  }
+  /**
+   * Regenerate API keys. Uses session token in body (no default auth).
+   *
+   * @example
+   * ```typescript
+   * const newKeys = await client.developer.regenerateKeys({
+   *   session_token: 'session_token_here',
+   *   key_type: 'test'
+   * });
+   * console.log(newKeys.api_key_test);
+   * ```
+   */
+  async regenerateKeys(request) {
+    if (!request.session_token) {
+      throw new Error("session_token is required");
+    }
+    if (!request.key_type) {
+      throw new Error("key_type is required");
+    }
+    return this.http.request(
+      "POST",
+      "/regenerate-keys",
+      { body: request, skipDefaultAuth: true }
+    );
+  }
+};
+
+// src/advertiser-client.ts
+var AdvertiserClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Sign up as a new advertiser. No API key auth needed.
+   *
+   * @example
+   * ```typescript
+   * const account = await client.advertiser.signup({
+   *   email: 'ads@company.com',
+   *   password: 'secure123',
+   *   company_name: 'Acme Corp'
+   * });
+   * console.log(account.advertiser_id);
+   * ```
+   */
+  async signup(request) {
+    if (!request.email) {
+      throw new Error("email is required");
+    }
+    if (!request.password) {
+      throw new Error("password is required");
+    }
+    if (!request.company_name) {
+      throw new Error("company_name is required");
+    }
+    return this.http.request(
+      "POST",
+      "/advertiser-signup",
+      { body: request, skipDefaultAuth: true }
+    );
+  }
+  /**
+   * Log in as an advertiser. Returns a session token.
+   * No API key auth needed.
+   *
+   * @example
+   * ```typescript
+   * const session = await client.advertiser.login({
+   *   email: 'ads@company.com',
+   *   password: 'secure123'
+   * });
+   * console.log(session.session_token);
+   * ```
+   */
+  async login(request) {
+    if (!request.email) {
+      throw new Error("email is required");
+    }
+    if (!request.password) {
+      throw new Error("password is required");
+    }
+    return this.http.request(
+      "POST",
+      "/advertiser-login",
+      { body: request, skipDefaultAuth: true }
+    );
+  }
+  /**
+   * Get advertiser stats. Uses X-Advertiser-Key header or query param.
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.advertiser.getStats({
+   *   advertiser_key: 'adv_key_123',
+   *   period: '30d'
+   * });
+   * console.log(stats.budget.remaining);
+   * ```
+   */
+  async getStats(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.advertiser_key) {
+      queryParams.append("advertiser_key", params.advertiser_key);
+    }
+    if (params?.period) {
+      queryParams.append("period", params.period);
+    }
+    const qs = queryParams.toString();
+    const url = `/advertiser-stats${qs ? "?" + qs : ""}`;
+    const headers = {};
+    if (params?.advertiser_key) {
+      headers["X-Advertiser-Key"] = params.advertiser_key;
+    }
+    return this.http.request(
+      "GET",
+      url,
+      { skipDefaultAuth: true, headers }
+    );
+  }
+  /**
+   * Get advertiser analytics. Uses session token in body (no default auth).
+   *
+   * @example
+   * ```typescript
+   * const analytics = await client.advertiser.getAnalytics('session_token', {
+   *   start_date: '2026-01-01',
+   *   group_by: 'week'
+   * });
+   * ```
+   */
+  async getAnalytics(sessionToken, params) {
+    if (!sessionToken) {
+      throw new Error("sessionToken is required");
+    }
+    return this.http.request(
+      "POST",
+      "/advertiser-analytics",
+      {
+        body: { session_token: sessionToken, ...params },
+        skipDefaultAuth: true
+      }
+    );
+  }
+  /**
+   * Create a new campaign. Uses JWT bearer token for auth.
+   *
+   * @example
+   * ```typescript
+   * const campaign = await client.advertiser.createCampaign('jwt_token', {
+   *   name: 'Summer Sale',
+   *   ad_type: 'link',
+   *   daily_budget: 5000,
+   *   bid_amount: 100,
+   *   creative: {
+   *     title: 'Summer Sale - 50% Off',
+   *     body: 'Limited time offer',
+   *     cta: 'Shop Now',
+   *     landing_url: 'https://example.com/sale'
+   *   }
+   * });
+   * ```
+   */
+  async createCampaign(jwt, request) {
+    if (!jwt) {
+      throw new Error("jwt is required for campaign creation");
+    }
+    if (!request.name) {
+      throw new Error("name is required");
+    }
+    if (!request.ad_type) {
+      throw new Error("ad_type is required");
+    }
+    if (!request.creative) {
+      throw new Error("creative is required");
+    }
+    return this.http.request(
+      "POST",
+      "/campaign-create",
+      {
+        body: request,
+        skipDefaultAuth: true,
+        headers: { "Authorization": `Bearer ${jwt}` }
+      }
+    );
+  }
+  /**
+   * Update an existing campaign. Uses session token in body (no default auth).
+   *
+   * @example
+   * ```typescript
+   * const result = await client.advertiser.updateCampaign({
+   *   campaign_id: 'camp_123',
+   *   session_token: 'session_token',
+   *   updates: { name: 'Updated Campaign Name' },
+   *   status: 'paused'
+   * });
+   * ```
+   */
+  async updateCampaign(request) {
+    if (!request.campaign_id) {
+      throw new Error("campaign_id is required");
+    }
+    if (!request.session_token) {
+      throw new Error("session_token is required");
+    }
+    return this.http.request(
+      "POST",
+      "/campaign-update",
+      { body: request, skipDefaultAuth: true }
+    );
+  }
+};
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://peruwnbrqkvmrldhpoom.supabase.co/functions/v1";
 var DEFAULT_TIMEOUT_MS = 4e3;
@@ -501,6 +939,12 @@ var AttentionMarketClient = class {
   http;
   agentId;
   appId;
+  /** Capability session management (multi-turn AI sessions) */
+  sessions;
+  /** Developer portal (login, earnings, stats, analytics) */
+  developer;
+  /** Advertiser portal (signup, login, campaigns, stats) */
+  advertiser;
   constructor(config) {
     this.agentId = config.agentId;
     this.appId = config.appId;
@@ -515,6 +959,9 @@ var AttentionMarketClient = class {
       httpConfig.supabaseAnonKey = config.supabaseAnonKey;
     }
     this.http = new HTTPClient(httpConfig);
+    this.sessions = new SessionClient(this.http);
+    this.developer = new DeveloperClient(this.http);
+    this.advertiser = new AdvertiserClient(this.http);
   }
   /**
    * Validate SDK configuration for security
@@ -713,7 +1160,8 @@ var AttentionMarketClient = class {
       // Developer controls (Phase 2: Revenue Optimization)
       ...params.minCPC !== void 0 && { minCPC: params.minCPC },
       ...params.minRelevanceScore !== void 0 && { minRelevanceScore: params.minRelevanceScore },
-      ...params.optimizeFor && { optimizeFor: params.optimizeFor }
+      ...params.optimizeFor && { optimizeFor: params.optimizeFor },
+      ...params.maxWaitMs !== void 0 && { max_wait_ms: params.maxWaitMs }
     };
     const response = await this.decideRaw(request, options);
     if (response && response.creative) {
@@ -865,6 +1313,24 @@ var AttentionMarketClient = class {
   async sendFeedback(request) {
     return await this.http.request("POST", "/feedback", { body: request });
   }
+  /**
+   * Rate the delivery quality of an ad after a verified click.
+   * Requires a prior click event for the tracking_token. Ratings feed
+   * into quality scores (minimum 5 unique raters per campaign).
+   *
+   * @example
+   * ```typescript
+   * await client.rateBusinessDelivery({
+   *   tracking_token: ad.tracking_token,
+   *   ad_unit_id: ad._ad.unit_id,
+   *   rating: 4,
+   *   context: 'Relevant product, good landing page'
+   * });
+   * ```
+   */
+  async rateBusinessDelivery(request) {
+    return await this.http.request("POST", "/rate-business", { body: request });
+  }
   /**
    * Fetch default policy constraints and formatting requirements.
    */
@@ -1393,7 +1859,122 @@ var AttentionMarketClient = class {
       url
     );
   }
-  // TODO: Add getDeveloperMetrics() method when DeveloperMetricsResponse type is defined
+  // ==========================================================================
+  // New Methods (v0.18.0)
+  // ==========================================================================
+  /**
+   * Sign up a new agent using the v2 endpoint.
+   * Static method — no API key needed.
+   *
+   * @example
+   * ```typescript
+   * const agent = await AttentionMarketClient.signupAgentV2({
+   *   owner_email: 'dev@example.com',
+   *   agent_name: 'My Agent',
+   *   sdk: 'typescript'
+   * });
+   * console.log(agent.api_key_live);
+   * ```
+   */
+  static async signupAgentV2(request, baseUrl) {
+    if (!request.owner_email) {
+      throw new Error("owner_email is required");
+    }
+    if (!request.agent_name) {
+      throw new Error("agent_name is required");
+    }
+    const http = new HTTPClient({
+      baseUrl: baseUrl ?? DEFAULT_BASE_URL,
+      timeoutMs: DEFAULT_TIMEOUT_MS,
+      maxRetries: DEFAULT_MAX_RETRIES
+    });
+    return http.request(
+      "POST",
+      "/agent-signup",
+      { body: request, skipDefaultAuth: true }
+    );
+  }
+  /**
+   * Track an agent-to-agent call using a tracking token.
+   *
+   * @example
+   * ```typescript
+   * await client.trackCall('trk_abc123', { model: 'gpt-4' });
+   * ```
+   */
+  async trackCall(token, metadata) {
+    if (!token) {
+      throw new Error("token is required for trackCall()");
+    }
+    return this.http.request(
+      "POST",
+      `/track-call/${encodeURIComponent(token)}`,
+      { body: metadata ? { metadata } : void 0 }
+    );
+  }
+  /**
+   * Scrape a website for knowledge base content.
+   * Requires Bearer JWT and an OpenAI API key header.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.scrapeSite(
+   *   { url: 'https://example.com', max_pages: 10 },
+   *   'jwt_token',
+   *   'sk-openai-key'
+   * );
+   * ```
+   */
+  async scrapeSite(request, jwt, openaiKey) {
+    if (!request.url) {
+      throw new Error("url is required");
+    }
+    if (!jwt) {
+      throw new Error("jwt is required for scrapeSite()");
+    }
+    if (!openaiKey) {
+      throw new Error("openaiKey is required for scrapeSite()");
+    }
+    return this.http.request(
+      "POST",
+      "/scrape-site",
+      {
+        body: request,
+        skipDefaultAuth: true,
+        headers: {
+          "Authorization": `Bearer ${jwt}`,
+          "x-openai-key": openaiKey
+        }
+      }
+    );
+  }
+  /**
+   * Train an agent with custom knowledge.
+   * No default auth — agent ID is in the request body.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.trainAgent({
+   *   agent_id: 'agt_123',
+   *   training_data: [
+   *     { type: 'document', content: 'Product FAQ...' }
+   *   ]
+   * });
+   * ```
+   */
+  async trainAgent(request) {
+    if (!request.agent_id) {
+      throw new Error("agent_id is required");
+    }
+    if (!request.training_data || request.training_data.length === 0) {
+      throw new Error("training_data is required and must not be empty");
+    }
+    return this.http.request(
+      "POST",
+      "/train-agent",
+      { body: request, skipDefaultAuth: true }
+    );
+  }
 };
 
 // src/mock-client.ts
@@ -1940,10 +2521,13 @@ function suggestTaxonomies(query) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   APIRequestError,
+  AdvertiserClient,
   AttentionMarketClient,
   AttentionMarketError,
+  DeveloperClient,
   MockAttentionMarketClient,
   NetworkError,
+  SessionClient,
   TimeoutError,
   buildTaxonomy,
   createImpressionEvent,