@vesper85/strategy-sdk 0.1.9 → 0.1.11

package/dist/clients/polymarket-client.d.ts

@@ -1,4 +1,4 @@
-import { GammaMarket, type Event as GammaEvent, type Tag, type Team, type Sport, type Series, type Comment as GammaComment, type SearchResults, type PaginatedResponse, type MarketFilters, type EventFilters, type EventPaginationFilters, type PaginationParams, type SearchParams } from "polymarket-gamma";
+import { GammaMarket, type Event as GammaEvent, type Tag, type Team, type Sport, type Series, type Comment as GammaComment, type SearchResults, type PaginatedResponse, type MarketFilters, type EventFilters, type EventPaginationFilters, type PaginationParams, type SearchParams } from "../gamma";
 import type { PolymarketAPI, PolymarketClientOptions, PolymarketLimitOrderParams, PolymarketMarketOrderParams, PolymarketOrderResponse, PolymarketOpenOrder, PolymarketCancelResponse, PolymarketOrderBook, PolymarketApprovalResult, SignerAPI } from "../types/osiris";
 import type { Logger } from "../utils/logger";
 export declare class PolymarketClient implements PolymarketAPI {

package/dist/gamma/client.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Polymarket Gamma API Client
+ * Inlined from polymarket-gamma package to avoid dependency issues
+ */
+import type { Comment, Event, EventFilters, EventPaginationFilters, GammaMarket, MarketFilters, PaginatedResponse, PaginationParams, SearchParams, SearchResults, Series, Sport, Tag, Team } from './types';
+/**
+ * Configuration options for the Gamma client
+ */
+export interface GammaClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    enableCache?: boolean;
+}
+/**
+ * Polymarket Gamma API Client
+ * Provides methods to access prediction markets, events, tags, and related data
+ */
+export declare class PolymarketGammaClient {
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly fetchFn;
+    private readonly customHeaders;
+    private readonly enableCache;
+    private readonly requestCache;
+    /**
+     * Creates a new Polymarket Gamma API client
+     * @param config - Optional configuration
+     */
+    constructor(config?: GammaClientConfig);
+    /**
+     * Parse JSON string fields that the API returns as strings instead of arrays/objects
+     */
+    private parseJsonFields;
+    /**
+     * Validate API response to ensure it's a valid object
+     */
+    private validateResponse;
+    /**
+     * Internal method to make HTTP requests with deduplication
+     */
+    private request;
+    /**
+     * Perform the actual HTTP request
+     */
+    private doRequest;
+    /**
+     * Internal method to make POST requests
+     */
+    private post;
+    /**
+     * Search across events, tags, and profiles
+     * @param params - Search parameters
+     * @returns Search results
+     */
+    search(params: SearchParams): Promise<SearchResults>;
+    /**
+     * Get a market by ID or slug
+     * @param idOrSlug - Market ID or slug
+     * @returns Market details
+     */
+    getMarket(idOrSlug: string): Promise<GammaMarket>;
+    /**
+     * Get markets with optional filtering and pagination
+     * @param filters - Filter and pagination parameters
+     * @returns Array of markets
+     */
+    getMarkets(filters?: MarketFilters): Promise<GammaMarket[]>;
+    /**
+     * Get tags for a specific market
+     * @param marketId - Market ID
+     * @returns Array of tags
+     */
+    getMarketTags(marketId: string): Promise<Tag[]>;
+    /**
+     * Get an event by ID or slug
+     * @param idOrSlug - Event ID or slug
+     * @returns Event details
+     */
+    getEvent(idOrSlug: string): Promise<Event>;
+    /**
+     * Get events with optional filtering and pagination
+     * @param filters - Filter and pagination parameters
+     * @returns Array of events
+     */
+    getEvents(filters?: EventFilters): Promise<Event[]>;
+    /**
+     * Get tags for a specific event
+     * @param eventId - Event ID
+     * @returns Array of tags
+     */
+    getEventTags(eventId: string): Promise<Tag[]>;
+    /**
+     * Get events with pagination metadata
+     * @param filters - Filter and pagination parameters
+     * @returns Paginated response with events and metadata
+     */
+    getEventsPaginated(filters?: EventPaginationFilters): Promise<PaginatedResponse<Event>>;
+    /**
+     * Get all tags
+     * @param params - Optional pagination parameters
+     * @returns Array of tags
+     */
+    getTags(params?: PaginationParams): Promise<Tag[]>;
+    /**
+     * Get a specific tag by ID or slug
+     * @param idOrSlug - Tag ID or slug
+     * @returns Tag details
+     */
+    getTag(idOrSlug: string): Promise<Tag>;
+    /**
+     * Get related tags for a specific tag
+     * @param idOrSlug - Tag ID or slug
+     * @returns Array of related tags
+     */
+    getRelatedTags(idOrSlug: string): Promise<Tag[]>;
+    /**
+     * Get all tags related to a specific tag
+     * @param idOrSlug - Tag ID or slug
+     * @returns Array of tags
+     */
+    getRelatedTagsTags(idOrSlug: string): Promise<Tag[]>;
+    /**
+     * Get all teams
+     * @param params - Optional pagination parameters
+     * @returns Array of teams
+     */
+    getTeams(params?: PaginationParams): Promise<Team[]>;
+    /**
+     * Get all sports
+     * @param params - Optional pagination parameters
+     * @returns Array of sports
+     */
+    getSports(params?: PaginationParams): Promise<Sport[]>;
+    /**
+     * Get all series
+     * @param params - Optional pagination parameters
+     * @returns Array of series
+     */
+    getSeries(params?: PaginationParams): Promise<Series[]>;
+    /**
+     * Get a specific series by ID
+     * @param seriesId - Series ID
+     * @returns Series details
+     */
+    getSeriesById(seriesId: string): Promise<Series>;
+    /**
+     * Get comments with optional filtering
+     * @param params - Optional pagination and filter parameters
+     * @returns Array of comments
+     */
+    getComments(params?: PaginationParams): Promise<Comment[]>;
+    /**
+     * Get a specific comment by ID
+     * @param commentId - Comment ID
+     * @returns Comment details
+     */
+    getComment(commentId: string): Promise<Comment>;
+    /**
+     * Get comments by user address
+     * @param userAddress - User's Ethereum address
+     * @param params - Optional pagination parameters
+     * @returns Array of comments
+     */
+    getCommentsByUser(userAddress: string, params?: PaginationParams): Promise<Comment[]>;
+    /**
+     * Get Grok AI-powered event summary
+     * @param eventSlug - Event slug
+     * @returns Event summary text
+     */
+    grokEventSummary(eventSlug: string): Promise<string>;
+    /**
+     * Get Grok AI-powered election market explanation
+     * @param marketSlug - Market slug
+     * @returns Market explanation text
+     */
+    grokElectionMarketExplanation(marketSlug: string): Promise<string>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/gamma/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Polymarket Gamma API - Inlined
+ * Re-exports types and client for internal use
+ */
+export { PolymarketGammaClient } from './client';
+export type { GammaClientConfig } from './client';
+export type { Category, ClobReward, Collection, Comment, Creator, Event, EventFilters, EventPaginationFilters, GammaMarket, MarketFilters, PaginatedResponse, PaginationMetadata, PaginationParams, Profile, Reaction, SearchParams, SearchResults, Series, Sport, Tag, Team, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/gamma/types.d.ts

@@ -0,0 +1,339 @@
+/**
+ * TypeScript type definitions for Polymarket Gamma API
+ * Inlined from polymarket-gamma package to avoid dependency issues
+ */
+/**
+ * Represents a prediction market on Polymarket
+ */
+export interface GammaMarket {
+    id?: string;
+    condition_id?: string;
+    question_id?: string;
+    slug?: string;
+    question?: string;
+    twitter_card_image?: string;
+    resolution_source?: string;
+    end_date?: string;
+    category?: string;
+    amm_type?: string;
+    liquidity?: number;
+    sponsor_name?: string;
+    sponsor_image?: string;
+    start_date?: string;
+    x_axis_value?: string;
+    y_axis_value?: string;
+    denomination_token?: string;
+    fee?: string;
+    image?: string;
+    icon?: string;
+    lower_bound?: string;
+    upper_bound?: string;
+    description?: string;
+    outcomes?: string[];
+    outcome_prices?: string[];
+    outcomePrices?: string[];
+    volume?: string;
+    active?: boolean;
+    market_type?: string;
+    format_type?: string;
+    lower_bound_date?: string;
+    upper_bound_date?: string;
+    closed?: boolean;
+    market_maker_address?: string;
+    created_by?: number;
+    updated_by?: number;
+    created_at?: string;
+    updated_at?: string;
+    closed_time?: string;
+    wide_format?: boolean;
+    new?: boolean;
+    mailchimp_tag?: string;
+    featured?: boolean;
+    archived?: boolean;
+    resolved_by?: string;
+    restricted?: boolean;
+    market_group?: number;
+    group_item_title?: string;
+    group_item_threshold?: string;
+    uma_end_date?: string;
+    seconds_delay?: number;
+    notification_policy?: number;
+    pager_duty_notification_enabled?: boolean;
+    reward_pool?: number;
+    reward_epoch?: number;
+    reward_multiplier?: number;
+    reward_min_size?: number;
+    reward_max_spread?: number;
+    ready?: boolean;
+    enable_order_book?: boolean;
+    notification_type?: string;
+    uma_reward?: string;
+    uma_resolution_statuses?: string[];
+    umaResolutionStatuses?: string[];
+    question_title?: string;
+    enable_ask?: boolean;
+    notifications?: number[];
+    events?: Event[];
+    markets?: GammaMarket[];
+    clob_token_ids?: string[];
+    clobTokenIds?: string[];
+    clobRewards?: ClobReward[];
+    tags?: Tag[];
+    cyom?: boolean;
+    competitive?: number;
+    neg_risk?: boolean;
+    neg_risk_market_id?: string;
+    neg_risk_request_id?: string;
+    accepting_orders?: boolean;
+    accepting_order_timestamp?: string;
+    minimum_order_size?: number;
+    minimum_tick_size?: number;
+    taker_fee_bps?: number;
+    maker_fee_bps?: number;
+    minimum_tick_size_usd?: number;
+    maker_base_fee?: number;
+    taker_base_fee?: number;
+    best_bid?: string;
+    best_ask?: string;
+    spread?: number;
+    spread_percent?: number;
+    volume_24hr?: string;
+    volume_num_trades_24hr?: number;
+    last_trade_price?: string;
+    last_trade_time?: string;
+    open_interest?: string;
+    rewards_daily_rate?: number;
+    rewards_min_size?: number;
+    rewards_max_spread?: number;
+    seconds_delay_requested?: number;
+    auto_update_schema?: boolean;
+    active_trading_prompt?: boolean;
+}
+/**
+ * Represents an event that contains one or more markets
+ */
+export interface Event {
+    id?: string;
+    slug?: string;
+    title?: string;
+    description?: string;
+    start_date?: string;
+    end_date?: string;
+    image?: string;
+    icon?: string;
+    created_at?: string;
+    updated_at?: string;
+    archived?: boolean;
+    active?: boolean;
+    closed?: boolean;
+    restricted?: boolean;
+    liquidity?: number;
+    volume?: string;
+    markets?: GammaMarket[];
+    tags?: Tag[];
+    categories?: Category[];
+    series?: Series[];
+    comment_count?: number;
+    enable_comment?: boolean;
+    ticker?: string;
+}
+/**
+ * Represents a series or tournament of related events
+ */
+export interface Series {
+    id?: string;
+    slug?: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    created_at?: string;
+    updated_at?: string;
+    events?: Event[];
+    categories?: Category[];
+}
+/**
+ * Represents a category for organizing markets and events
+ */
+export interface Category {
+    id?: string;
+    label?: string;
+    slug?: string;
+}
+/**
+ * Represents a tag for organizing and filtering content
+ */
+export interface Tag {
+    id?: string;
+    label?: string;
+    slug?: string;
+    description?: string;
+    event_count?: number;
+    market_count?: number;
+    parent_id?: string;
+    children?: Tag[];
+}
+/**
+ * Represents a user profile
+ */
+export interface Profile {
+    id?: string;
+    name?: string;
+    username?: string;
+    avatar_url?: string;
+    bio?: string;
+}
+/**
+ * Represents a comment on a market or event
+ */
+export interface Comment {
+    id?: string;
+    market_id?: string;
+    event_id?: string;
+    user?: Profile;
+    content?: string;
+    created_at?: string;
+    updated_at?: string;
+    parent_id?: string;
+    reactions?: Reaction[];
+    reply_count?: number;
+}
+/**
+ * Represents a reaction to a comment
+ */
+export interface Reaction {
+    id?: string;
+    comment_id?: string;
+    user?: Profile;
+    type?: string;
+    created_at?: string;
+}
+/**
+ * Represents a sports team
+ */
+export interface Team {
+    id?: string;
+    name?: string;
+    short_name?: string;
+    abbreviation?: string;
+    logo?: string;
+    sport_id?: string;
+    sport?: Sport;
+}
+/**
+ * Represents a sport
+ */
+export interface Sport {
+    id?: string;
+    name?: string;
+    slug?: string;
+}
+/**
+ * Represents a CLOB (Central Limit Order Book) reward
+ */
+export interface ClobReward {
+    id?: string;
+    market_id?: string;
+    event_id?: string;
+    reward_epoch?: number;
+    asset_address?: string;
+    reward_amount?: string;
+    start_date?: string;
+    end_date?: string;
+}
+/**
+ * Represents a collection of markets
+ */
+export interface Collection {
+    id?: string;
+    title?: string;
+    slug?: string;
+    description?: string;
+    markets?: GammaMarket[];
+}
+/**
+ * Represents a market creator
+ */
+export interface Creator {
+    id?: string;
+    name?: string;
+    avatar_url?: string;
+}
+/**
+ * Search results wrapper
+ */
+export interface SearchResults {
+    events?: Event[];
+    tags?: Tag[];
+    profiles?: Profile[];
+}
+/**
+ * Pagination parameters for list queries
+ */
+export interface PaginationParams {
+    limit?: number;
+    offset?: number;
+    [key: string]: unknown;
+}
+/**
+ * Filter parameters for markets
+ */
+export interface MarketFilters extends PaginationParams {
+    active?: boolean;
+    closed?: boolean;
+    archived?: boolean;
+    featured?: boolean;
+    restricted?: boolean;
+    tags?: string[];
+    category?: string;
+    event_id?: string;
+    order_by?: string;
+    ascending?: boolean;
+}
+/**
+ * Filter parameters for events
+ */
+export interface EventFilters extends PaginationParams {
+    active?: boolean;
+    closed?: boolean;
+    archived?: boolean;
+    restricted?: boolean;
+    tags?: string[];
+    category?: string;
+    series_id?: string;
+    order_by?: string;
+    ascending?: boolean;
+}
+/**
+ * Search parameters
+ */
+export interface SearchParams {
+    query: string;
+    limit?: number;
+    offset?: number;
+    [key: string]: unknown;
+}
+/**
+ * Pagination metadata
+ */
+export interface PaginationMetadata {
+    hasMore: boolean;
+    totalResults: number;
+}
+/**
+ * Paginated response wrapper
+ */
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: PaginationMetadata;
+}
+/**
+ * Pagination filter parameters for events
+ */
+export interface EventPaginationFilters extends PaginationParams {
+    active?: boolean;
+    closed?: boolean;
+    archived?: boolean;
+    order?: string;
+    ascending?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/index.d.ts

@@ -13,4 +13,6 @@ export { PolymarketEventRunner, createPolymarketEventRunner, type PolymarketEven
 export { UnifiedRTDSService, createUnifiedRTDSService, PolymarketRTDSService, createPolymarketRTDSService, OsirisRTDSService, createOsirisRTDSService, DEFAULT_OSIRIS_RTDS_URL, type UnifiedRTDSConfig, type PolymarketRTDSConfig, type OsirisRTDSConfig, type ClobApiKeyCreds, } from './rtds';
 export { createConsoleLogger, type Logger, } from './utils/logger';
 export { Signer, OsirisSigner, PrivateKeySigner, type ISigner, type SignerConfig, type OsirisSignerConfig, type PrivateKeySignerConfig, } from './signer';
+export { PolymarketGammaClient, type GammaClientConfig, } from './gamma';
+export type { Category, ClobReward, Collection, Comment, Creator, Event, EventFilters, EventPaginationFilters, GammaMarket, MarketFilters, PaginatedResponse, PaginationMetadata, PaginationParams, Profile, Reaction, SearchParams, SearchResults, Series, Sport, Tag, Team, } from './gamma';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,3 @@
-import { PolymarketGammaClient } from 'polymarket-gamma';
 import { ClobClient, Side } from '@polymarket/clob-client';
 import { ethers } from 'ethers';
 import axios from 'axios';
@@ -51,6 +50,361 @@ function isPolymarketSubscription(sub) {
 function isOsirisSubscription(sub) {
   return isWalletSubscription(sub) || isOpportunitySubscription(sub);
 }
+
+// src/gamma/client.ts
+var PolymarketGammaClient = class {
+  baseUrl;
+  timeout;
+  fetchFn;
+  customHeaders;
+  enableCache;
+  requestCache = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new Polymarket Gamma API client
+   * @param config - Optional configuration
+   */
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl ?? "https://gamma-api.polymarket.com";
+    this.timeout = config.timeout ?? 3e4;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+    this.customHeaders = config.headers ?? {};
+    this.enableCache = config.enableCache ?? true;
+  }
+  /**
+   * Parse JSON string fields that the API returns as strings instead of arrays/objects
+   */
+  parseJsonFields(data) {
+    if (!data || typeof data !== "object") {
+      return data;
+    }
+    if (Array.isArray(data)) {
+      return data.map((item) => this.parseJsonFields(item));
+    }
+    const parsed = {};
+    const jsonStringFields = [
+      "outcomes",
+      "outcome_prices",
+      "outcomePrices",
+      "clob_token_ids",
+      "clobTokenIds",
+      "uma_resolution_statuses",
+      "umaResolutionStatuses"
+    ];
+    for (const [key, value] of Object.entries(data)) {
+      if (jsonStringFields.includes(key) && typeof value === "string" && value.startsWith("[")) {
+        try {
+          parsed[key] = JSON.parse(value);
+        } catch {
+          parsed[key] = value;
+        }
+      } else if (value && typeof value === "object") {
+        parsed[key] = this.parseJsonFields(value);
+      } else {
+        parsed[key] = value;
+      }
+    }
+    return parsed;
+  }
+  /**
+   * Validate API response to ensure it's a valid object
+   */
+  validateResponse(data, endpoint) {
+    if (data === null || typeof data !== "object") {
+      throw new Error(
+        `Invalid response from ${endpoint}: expected object, got ${data === null ? "null" : typeof data}`
+      );
+    }
+    return data;
+  }
+  /**
+   * Internal method to make HTTP requests with deduplication
+   */
+  async request(endpoint, params) {
+    if (!this.enableCache) {
+      return this.doRequest(endpoint, params);
+    }
+    let cacheKey;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              searchParams.append(key, String(item));
+            }
+          } else {
+            searchParams.append(key, String(value));
+          }
+        }
+      }
+      cacheKey = `${endpoint}?${searchParams.toString()}`;
+    } else {
+      cacheKey = endpoint;
+    }
+    if (this.requestCache.has(cacheKey)) {
+      return this.requestCache.get(cacheKey);
+    }
+    const promise = this.doRequest(endpoint, params);
+    this.requestCache.set(cacheKey, promise);
+    promise.finally(() => {
+      setTimeout(() => this.requestCache.delete(cacheKey), 100);
+    });
+    return promise;
+  }
+  /**
+   * Perform the actual HTTP request
+   */
+  async doRequest(endpoint, params) {
+    const url = new URL(endpoint, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              url.searchParams.append(key, String(item));
+            }
+          } else {
+            url.searchParams.append(key, String(value));
+          }
+        }
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchFn(url.toString(), {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.customHeaders
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const validated = this.validateResponse(data, endpoint);
+      return this.parseJsonFields(validated);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Internal method to make POST requests
+   */
+  async post(url, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchFn(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.customHeaders
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.validateResponse(data, url);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // ==================== Search Methods ====================
+  /**
+   * Search across events, tags, and profiles
+   * @param params - Search parameters
+   * @returns Search results
+   */
+  async search(params) {
+    return this.request("/public-search", params);
+  }
+  // ==================== Market Methods ====================
+  /**
+   * Get a market by ID or slug
+   * @param idOrSlug - Market ID or slug
+   * @returns Market details
+   */
+  async getMarket(idOrSlug) {
+    const endpoint = idOrSlug.includes("-") ? `/markets/slug/${idOrSlug}` : `/markets/${idOrSlug}`;
+    return this.request(endpoint);
+  }
+  /**
+   * Get markets with optional filtering and pagination
+   * @param filters - Filter and pagination parameters
+   * @returns Array of markets
+   */
+  async getMarkets(filters) {
+    return this.request("/markets", filters);
+  }
+  /**
+   * Get tags for a specific market
+   * @param marketId - Market ID
+   * @returns Array of tags
+   */
+  async getMarketTags(marketId) {
+    return this.request(`/markets/${marketId}/tags`);
+  }
+  // ==================== Event Methods ====================
+  /**
+   * Get an event by ID or slug
+   * @param idOrSlug - Event ID or slug
+   * @returns Event details
+   */
+  async getEvent(idOrSlug) {
+    const endpoint = idOrSlug.includes("-") ? `/events/slug/${idOrSlug}` : `/events/${idOrSlug}`;
+    return this.request(endpoint);
+  }
+  /**
+   * Get events with optional filtering and pagination
+   * @param filters - Filter and pagination parameters
+   * @returns Array of events
+   */
+  async getEvents(filters) {
+    return this.request("/events", filters);
+  }
+  /**
+   * Get tags for a specific event
+   * @param eventId - Event ID
+   * @returns Array of tags
+   */
+  async getEventTags(eventId) {
+    return this.request(`/events/${eventId}/tags`);
+  }
+  /**
+   * Get events with pagination metadata
+   * @param filters - Filter and pagination parameters
+   * @returns Paginated response with events and metadata
+   */
+  async getEventsPaginated(filters) {
+    return this.request("/events/pagination", filters);
+  }
+  // ==================== Tag Methods ====================
+  /**
+   * Get all tags
+   * @param params - Optional pagination parameters
+   * @returns Array of tags
+   */
+  async getTags(params) {
+    return this.request("/tags", params);
+  }
+  /**
+   * Get a specific tag by ID or slug
+   * @param idOrSlug - Tag ID or slug
+   * @returns Tag details
+   */
+  async getTag(idOrSlug) {
+    return this.request(`/tags/${idOrSlug}`);
+  }
+  /**
+   * Get related tags for a specific tag
+   * @param idOrSlug - Tag ID or slug
+   * @returns Array of related tags
+   */
+  async getRelatedTags(idOrSlug) {
+    const endpoint = idOrSlug.includes("-") ? `/tags/slug/${idOrSlug}/related-tags` : `/tags/${idOrSlug}/related-tags`;
+    return this.request(endpoint);
+  }
+  /**
+   * Get all tags related to a specific tag
+   * @param idOrSlug - Tag ID or slug
+   * @returns Array of tags
+   */
+  async getRelatedTagsTags(idOrSlug) {
+    const endpoint = idOrSlug.includes("-") ? `/tags/slug/${idOrSlug}/related-tags/tags` : `/tags/${idOrSlug}/related-tags/tags`;
+    return this.request(endpoint);
+  }
+  // ==================== Team and Sport Methods ====================
+  /**
+   * Get all teams
+   * @param params - Optional pagination parameters
+   * @returns Array of teams
+   */
+  async getTeams(params) {
+    return this.request("/teams", params);
+  }
+  /**
+   * Get all sports
+   * @param params - Optional pagination parameters
+   * @returns Array of sports
+   */
+  async getSports(params) {
+    return this.request("/sports", params);
+  }
+  // ==================== Series Methods ====================
+  /**
+   * Get all series
+   * @param params - Optional pagination parameters
+   * @returns Array of series
+   */
+  async getSeries(params) {
+    return this.request("/series", params);
+  }
+  /**
+   * Get a specific series by ID
+   * @param seriesId - Series ID
+   * @returns Series details
+   */
+  async getSeriesById(seriesId) {
+    return this.request(`/series/${seriesId}`);
+  }
+  // ==================== Comment Methods ====================
+  /**
+   * Get comments with optional filtering
+   * @param params - Optional pagination and filter parameters
+   * @returns Array of comments
+   */
+  async getComments(params) {
+    return this.request("/comments", params);
+  }
+  /**
+   * Get a specific comment by ID
+   * @param commentId - Comment ID
+   * @returns Comment details
+   */
+  async getComment(commentId) {
+    return this.request(`/comments/${commentId}`);
+  }
+  /**
+   * Get comments by user address
+   * @param userAddress - User's Ethereum address
+   * @param params - Optional pagination parameters
+   * @returns Array of comments
+   */
+  async getCommentsByUser(userAddress, params) {
+    return this.request(`/comments/user_address/${userAddress}`, params);
+  }
+  // ==================== Grok AI Methods ====================
+  /**
+   * Get Grok AI-powered event summary
+   * @param eventSlug - Event slug
+   * @returns Event summary text
+   */
+  async grokEventSummary(eventSlug) {
+    const response = await this.post(
+      "https://polymarket.com/api/grok/event-summary",
+      { event_slug: eventSlug }
+    );
+    return response.summary;
+  }
+  /**
+   * Get Grok AI-powered election market explanation
+   * @param marketSlug - Market slug
+   * @returns Market explanation text
+   */
+  async grokElectionMarketExplanation(marketSlug) {
+    const response = await this.post(
+      "https://polymarket.com/api/grok/election-market-explanation",
+      { market_slug: marketSlug }
+    );
+    return response.explanation;
+  }
+};
 var OsirisSigner = class {
   hubBaseUrl;
   accessToken;
@@ -3798,6 +4152,6 @@ var Signer = class {
   }
 };
 
-export { DEFAULT_OSIRIS_RTDS_URL, HyperliquidClient, MemoryStateManager, OsirisEventRunner, OsirisRTDSService, OsirisSigner, PolymarketClient, PolymarketEventRunner, PolymarketRTDSService, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, UnifiedRTDSService, createConsoleLogger, createEventRunner, createOsirisContext, createOsirisRTDSService, createPolymarketEventRunner, createPolymarketRTDSService, createStrategyEngine, createUnifiedRTDSService, isActivitySubscription, isClobMarketSubscription, isClobUserSubscription, isCommentsSubscription, isCryptoPricesSubscription, isCustomSubscription, isEventBasedStrategy, isMarketSubscription, isOpportunitySubscription, isOsirisSubscription, isPolymarketSubscription, isRfqSubscription, isTickBasedStrategy, isWalletSubscription, runStrategy, validateStrategy };
+export { DEFAULT_OSIRIS_RTDS_URL, HyperliquidClient, MemoryStateManager, OsirisEventRunner, OsirisRTDSService, OsirisSigner, PolymarketClient, PolymarketEventRunner, PolymarketGammaClient, PolymarketRTDSService, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, UnifiedRTDSService, createConsoleLogger, createEventRunner, createOsirisContext, createOsirisRTDSService, createPolymarketEventRunner, createPolymarketRTDSService, createStrategyEngine, createUnifiedRTDSService, isActivitySubscription, isClobMarketSubscription, isClobUserSubscription, isCommentsSubscription, isCryptoPricesSubscription, isCustomSubscription, isEventBasedStrategy, isMarketSubscription, isOpportunitySubscription, isOsirisSubscription, isPolymarketSubscription, isRfqSubscription, isTickBasedStrategy, isWalletSubscription, runStrategy, validateStrategy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/types/osiris.d.ts

@@ -1,5 +1,5 @@
 import type { OHLCV, TAParams } from "@vesper85/technical-indicators";
-import type { Event as GammaEvent, Tag, Team, Sport, Series, Comment as GammaComment, SearchResults, PaginatedResponse, MarketFilters, EventFilters, EventPaginationFilters, PaginationParams, SearchParams, GammaMarket } from "polymarket-gamma";
+import type { Event as GammaEvent, Tag, Team, Sport, Series, Comment as GammaComment, SearchResults, PaginatedResponse, MarketFilters, EventFilters, EventPaginationFilters, PaginationParams, SearchParams, GammaMarket } from "../gamma";
 import type { ClearinghouseState, SpotMeta, SpotClearinghouseState, SpotMetaAndAssetCtxs, Meta, MetaAndAssetCtxs, UserFunding, UserNonFundingLedgerUpdates, FundingHistory, PredictedFundings, PerpsAtOpenInterestCap, PerpDexLimits, AllMids, UserOpenOrders, FrontendOpenOrders, UserFills, UserRateLimit, OrderStatus, L2Book, CandleSnapshot, HistoricalOrder, TwapSliceFill, SubAccount, VaultDetails, VaultEquity, UserRole, Delegation, DelegatorSummary, DelegatorHistoryEntry, DelegatorReward, ValidatorSummary, VaultSummary, UserFees, PortfolioPeriods, PreTransferCheck, Referral, ExtraAgent, LegalCheck, TwapHistory, MultiSigSigners, BuilderFeeApproval, UserOrderHistory } from "hyperliquid";
 export interface OsirisState {
     get(key: string): Promise<any>;

package/dist/utils/index.d.ts

@@ -1,3 +1,3 @@
-import { GammaMarket } from "polymarket-gamma";
+import { GammaMarket } from "../gamma";
 export declare function mapToGammaMarket(raw: any): GammaMarket;
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vesper85/strategy-sdk",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "description": "SDK for writing and running trading strategies with Polymarket and Hyperliquid integrations",
   "keywords": [
@@ -11,11 +11,9 @@
     "trading-bot",
     "osiris"
   ],
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./gs/index.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
@@ -54,9 +52,6 @@
     "superjson": "^2.2.6",
     "viem": "^2.30.1"
   },
-  "peerDependencies": {
-    "polymarket-gamma": "^0.4.0"
-  },
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
     "@osiris-ai/eslint-config": "workspace:*",