@hypercli.com/sdk 0.9.1

package/dist/agent.js

@@ -0,0 +1,926 @@
+/**
+ * HyperAgent API client - AI agent inference using OpenAI-compatible API
+ *
+ * Note: OpenAI client integration is not included in this SDK.
+ * Use the OpenAI Node.js SDK directly with HyperClaw endpoints.
+ */
+import { responseAPIError } from './http.js';
+import { getAgentsApiBaseUrl, getApiUrl } from './config.js';
+import { resolveAgentsApiBase } from './agent-urls.js';
+import { agentSlotFromDict } from './agent-slots.js';
+function resolveHyperAgentBaseUrl(productApiBaseUrl) {
+    const raw = (productApiBaseUrl || '').replace(/\/+$/, '');
+    if (!raw) {
+        const fallback = getApiUrl();
+        return resolveHyperAgentBaseUrl(fallback);
+    }
+    const parsed = new URL(raw.includes('://') ? raw : `https://${raw}`);
+    const host = parsed.host.toLowerCase();
+    if (host === 'api.hypercli.com' || host === 'api.hyperclaw.app' || host === 'api.agents.hypercli.com') {
+        return 'https://api.agents.hypercli.com/v1';
+    }
+    if (host === 'api.dev.hypercli.com' ||
+        host === 'api.dev.hyperclaw.app' ||
+        host === 'dev-api.hyperclaw.app' ||
+        host === 'api.agents.dev.hypercli.com') {
+        return 'https://api.agents.dev.hypercli.com/v1';
+    }
+    if (raw.endsWith('/api')) {
+        return `${raw.slice(0, -4)}/v1`;
+    }
+    if (raw.endsWith('/agents')) {
+        return `${raw.slice(0, -7)}/v1`;
+    }
+    return `${raw}/v1`;
+}
+function resolveHyperAgentControlBaseUrl(productApiBaseUrl, agentsApiBaseUrl, dev) {
+    return resolveAgentsApiBase(agentsApiBaseUrl || getAgentsApiBaseUrl(dev, productApiBaseUrl), true);
+}
+export const HYPER_AGENT_CANONICAL_PLAN_IDS = ['solo', 'team', 'pro'];
+export function parseHyperAgentPlanId(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return HYPER_AGENT_CANONICAL_PLAN_IDS.includes(normalized)
+        ? normalized
+        : null;
+}
+/** Whether any subscription or direct entitlement is currently active. */
+export function hasActivePlan(summary) {
+    return summary.activeSubscriptionCount > 0 || summary.activeEntitlementCount > 0;
+}
+function hyperAgentPlanFromDict(data) {
+    const agents = Number(data.agents ?? 0);
+    const maxAgentSize = ['small', 'medium', 'large'].includes(data.max_agent_size)
+        ? data.max_agent_size
+        : null;
+    const resources = data.agent_resources;
+    const explicitSlotGrants = data.slot_grants && typeof data.slot_grants === 'object'
+        ? Object.fromEntries(Object.entries(data.slot_grants)
+            .map(([tier, count]) => [tier, Number(count)])
+            .filter(([, count]) => Number.isFinite(count) && count > 0))
+        : {};
+    const slotGrants = Object.keys(explicitSlotGrants).length > 0
+        ? explicitSlotGrants
+        : maxAgentSize && agents > 0
+            ? { [maxAgentSize]: agents }
+            : {};
+    return {
+        id: data.id,
+        canonicalId: parseHyperAgentPlanId(data.id),
+        name: data.name,
+        price: data.price ?? data.price_usd ?? 0,
+        priceUsd: data.price_usd ?? data.price ?? 0,
+        aiu: data.aiu == null ? undefined : Number(data.aiu),
+        agents,
+        amountCents: Number(data.amount_cents ?? 0),
+        contractVersion: data.contract_version == null ? null : String(data.contract_version),
+        maxAgentSize,
+        slotGrants,
+        agentResources: resources && typeof resources === 'object' ? {
+            maxAgents: Number(resources.max_agents ?? agents),
+            totalCpu: Number(resources.total_cpu ?? 0),
+            totalMemory: Number(resources.total_memory ?? 0),
+        } : null,
+        features: data.features || [],
+        models: data.models || [],
+        highlighted: Boolean(data.highlighted),
+        expiresAt: data.expires_at ? new Date(String(data.expires_at).replace('Z', '+00:00')) : null,
+        limits: {
+            tpd: data.limits?.tpd || 0,
+            tpm: data.limits?.tpm || 0,
+            burstTpm: data.limits?.burst_tpm || 0,
+            rpm: data.limits?.rpm || 0,
+        },
+        tpmLimit: data.tpm_limit || data.limits?.tpm || 0,
+        rpmLimit: data.rpm_limit || data.limits?.rpm || 0,
+    };
+}
+function hyperAgentCurrentPlanFromDict(data) {
+    return {
+        id: data.id,
+        name: data.name,
+        price: data.price,
+        aiu: data.aiu,
+        agents: data.agents,
+        tpmLimit: data.tpm_limit || 0,
+        rpmLimit: data.rpm_limit || 0,
+        expiresAt: data.expires_at ? new Date(String(data.expires_at).replace('Z', '+00:00')) : null,
+        cancelAtPeriodEnd: Boolean(data.cancel_at_period_end),
+        provider: data.provider || undefined,
+        secondsRemaining: data.seconds_remaining ?? null,
+        pooledTpd: data.pooled_tpd || 0,
+        maxAgentSize: ['small', 'medium', 'large'].includes(data.max_agent_size)
+            ? data.max_agent_size
+            : null,
+        slotInventory: data.slot_inventory || undefined,
+        agentSlots: (data.agent_slots || []).map(agentSlotFromDict),
+    };
+}
+const ACTIVE_LIKE_SUBSCRIPTION_STATUSES = new Set(['active', 'trialing']);
+function nullableNumberFromDict(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function validDateFromDict(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const numericValue = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && /^-?\d+(?:\.\d+)?$/.test(value.trim())
+            ? Number(value)
+            : null;
+    const date = numericValue !== null && Number.isFinite(numericValue)
+        ? new Date(Math.abs(numericValue) < 1_000_000_000_000 ? numericValue * 1000 : numericValue)
+        : dateFromDict(value);
+    return date && Number.isFinite(date.getTime()) ? date : null;
+}
+function firstValidDateFromDict(...values) {
+    for (const value of values) {
+        const date = validDateFromDict(value);
+        if (date)
+            return date;
+    }
+    return null;
+}
+function hyperAgentSubscriptionTrialFromDict(data, meta, entitlements) {
+    if (Object.prototype.hasOwnProperty.call(data || {}, 'trial')) {
+        const trial = data.trial;
+        if (!trial || typeof trial !== 'object' || Array.isArray(trial))
+            return null;
+        return {
+            active: trial.active === true,
+            days: nullableNumberFromDict(trial.days),
+            startsAt: validDateFromDict(trial.starts_at),
+            endsAt: validDateFromDict(trial.ends_at),
+            secondsRemaining: nullableNumberFromDict(trial.seconds_remaining),
+        };
+    }
+    const trialMarker = meta?.trial;
+    const hasTrialMarker = trialMarker === true
+        || (typeof trialMarker === 'string' && trialMarker.trim().toLowerCase() === 'true');
+    const trialActiveMarker = meta?.trial_active;
+    const explicitlyInactive = trialActiveMarker === false
+        || (typeof trialActiveMarker === 'string' && trialActiveMarker.trim().toLowerCase() === 'false')
+        || Boolean(meta?.trial_ended_at)
+        || Boolean(data?.cancel_at_period_end);
+    const status = String(data?.status || '').trim().toLowerCase();
+    const trialDays = nullableNumberFromDict(meta?.trial_days);
+    const metadataStartsAt = firstValidDateFromDict(meta?.trial_starts_at, meta?.trial_started_at, meta?.trial_start_at, meta?.trial_start);
+    const metadataEndsAt = firstValidDateFromDict(meta?.trial_ends_at, meta?.trial_ended_at, meta?.trial_end_at, meta?.trial_end);
+    const entitlementStartsAt = entitlements
+        .map((entitlement) => entitlement.startsAt)
+        .filter((value) => Boolean(value && Number.isFinite(value.getTime())))
+        .sort((left, right) => left.getTime() - right.getTime())[0] ?? null;
+    const fallbackStartsAt = metadataStartsAt ?? entitlementStartsAt;
+    const derivedEndsAt = fallbackStartsAt && trialDays && trialDays > 0
+        ? new Date(fallbackStartsAt.getTime() + trialDays * 24 * 60 * 60 * 1000)
+        : null;
+    const periodEndsAt = validDateFromDict(data?.current_period_end ?? data?.expires_at);
+    const authoritativeEndsAt = metadataEndsAt ?? periodEndsAt;
+    let startsAt = metadataStartsAt;
+    if (!startsAt && authoritativeEndsAt && trialDays && trialDays > 0) {
+        startsAt = new Date(authoritativeEndsAt.getTime() - trialDays * 24 * 60 * 60 * 1000);
+    }
+    startsAt ??= entitlementStartsAt;
+    const hasPersistedTrialTiming = Boolean(metadataStartsAt
+        || metadataEndsAt
+        || (entitlementStartsAt && trialDays && trialDays > 0));
+    const now = Date.now();
+    const periodWouldReviveExpiredTrial = Boolean(!metadataEndsAt
+        && periodEndsAt
+        && periodEndsAt.getTime() > now
+        && derivedEndsAt
+        && derivedEndsAt.getTime() <= now);
+    const endsAt = authoritativeEndsAt ?? derivedEndsAt;
+    if (!hasTrialMarker
+        || explicitlyInactive
+        || !ACTIVE_LIKE_SUBSCRIPTION_STATUSES.has(status)
+        || !hasPersistedTrialTiming
+        || periodWouldReviveExpiredTrial
+        || !endsAt
+        || endsAt.getTime() <= now) {
+        return null;
+    }
+    return {
+        active: true,
+        days: trialDays,
+        startsAt,
+        endsAt,
+        secondsRemaining: Math.max(0, Math.floor((endsAt.getTime() - now) / 1000)),
+    };
+}
+function hyperAgentPaymentMethodSummaryFromDict(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return null;
+    const brand = data.brand == null ? null : String(data.brand);
+    const last4 = data.last4 == null ? null : String(data.last4);
+    if (!brand && !last4)
+        return null;
+    return {
+        brand,
+        last4,
+        expMonth: nullableNumberFromDict(data.exp_month),
+        expYear: nullableNumberFromDict(data.exp_year),
+    };
+}
+function hyperAgentSubscriptionFromDict(data) {
+    const periodEnd = data.current_period_end || data.expires_at || null;
+    const expiresAt = validDateFromDict(periodEnd);
+    const meta = data.meta ?? null;
+    const entitlements = (data.entitlements || []).map(hyperAgentEntitlementFromDict);
+    const directAgentSlots = (data.agent_slots || []).map(agentSlotFromDict);
+    const slotGrants = mergeSlotGrants(data.slot_grants, ...entitlements.map((entitlement) => entitlement.slotGrants));
+    return {
+        id: data.id || '',
+        userId: data.user_id || '',
+        planId: data.plan_id || '',
+        planName: data.plan_name || data.plan_id || '',
+        provider: data.provider || '',
+        status: data.status || '',
+        quantity: data.quantity || 1,
+        expiresAt,
+        updatedAt: data.updated_at ? new Date(String(data.updated_at).replace('Z', '+00:00')) : null,
+        stripeSubscriptionId: data.stripe_subscription_id || null,
+        paymentMethod: hyperAgentPaymentMethodSummaryFromDict(data.payment_method),
+        cancelAtPeriodEnd: Boolean(data.cancel_at_period_end),
+        canCancel: Boolean(data.can_cancel),
+        isCurrent: Boolean(data.is_current),
+        meta,
+        trial: hyperAgentSubscriptionTrialFromDict(data, meta, entitlements),
+        planTpmLimit: data.plan_tpm_limit || 0,
+        planRpmLimit: data.plan_rpm_limit || 0,
+        planTpd: data.plan_tpd || 0,
+        planAgentTier: data.plan_agent_tier || null,
+        slotGrants,
+        entitlements,
+        agentSlots: directAgentSlots.length > 0
+            ? directAgentSlots
+            : entitlements.flatMap((entitlement) => entitlement.agentSlots),
+    };
+}
+function mergeSlotGrants(...sources) {
+    const merged = {};
+    for (const source of sources) {
+        if (!source)
+            continue;
+        for (const [tier, value] of Object.entries(source)) {
+            const granted = Number(value || 0);
+            if (!Number.isFinite(granted) || granted <= 0)
+                continue;
+            merged[tier] = Math.max(merged[tier] || 0, granted);
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : null;
+}
+function hyperAgentEntitlementFromDict(data) {
+    return {
+        id: data.id || '',
+        userId: data.user_id || '',
+        subscriptionId: data.subscription_id || null,
+        planId: data.plan_id || '',
+        planName: data.plan_name || data.plan_id || '',
+        provider: data.provider || '',
+        status: data.status || '',
+        startsAt: dateFromDict(data.starts_at),
+        expiresAt: data.expires_at ? new Date(String(data.expires_at).replace('Z', '+00:00')) : null,
+        updatedAt: data.updated_at ? new Date(String(data.updated_at).replace('Z', '+00:00')) : null,
+        tpmLimit: data.tpm_limit || 0,
+        rpmLimit: data.rpm_limit || 0,
+        tpdLimit: data.tpd_limit || 0,
+        agentTier: data.agent_tier || null,
+        features: data.features || {},
+        tags: data.tags || [],
+        meta: data.meta || null,
+        slotGrants: data.slot_grants || null,
+        activeAgentCount: data.active_agent_count || 0,
+        activeAgentIds: data.active_agent_ids || [],
+        agentSlots: (data.agent_slots || []).map(agentSlotFromDict),
+    };
+}
+function hyperAgentGrantFromDict(data) {
+    return {
+        id: String(data?.id || ''),
+        userId: data?.user_id ?? null,
+        entitlementId: data?.entitlement_id ?? null,
+        type: String(data?.type || ''),
+        planId: String(data?.plan_id || ''),
+        duration: Number(data?.duration || 0),
+        code: data?.code ?? null,
+        tags: Array.isArray(data?.tags) ? data.tags.map(String) : [],
+        meta: data?.meta || null,
+        appliedAt: dateFromDict(data?.applied_at),
+        createdAt: dateFromDict(data?.created_at),
+        updatedAt: dateFromDict(data?.updated_at),
+    };
+}
+function hyperAgentEntitlementsFromDict(data) {
+    const payload = data?.entitlements && typeof data.entitlements === 'object' ? data.entitlements : data;
+    const billingResetAt = payload?.billing_reset_at || data?.billing_reset_at || null;
+    return {
+        effectivePlanId: payload?.effective_plan_id || data?.effective_plan_id || '',
+        pooledTpmLimit: payload?.pooled_tpm_limit || data?.pooled_tpm_limit || 0,
+        pooledRpmLimit: payload?.pooled_rpm_limit || data?.pooled_rpm_limit || 0,
+        pooledTpd: payload?.pooled_tpd || data?.pooled_tpd || 0,
+        slotInventory: payload?.slot_inventory || data?.slot_inventory || {},
+        activeEntitlementCount: payload?.active_entitlement_count || data?.active_entitlement_count || data?.active_subscription_count || 0,
+        billingResetAt: billingResetAt ? new Date(String(billingResetAt).replace('Z', '+00:00')) : null,
+        agentSlots: (payload?.agent_slots || data?.agent_slots || []).map(agentSlotFromDict),
+    };
+}
+function hyperAgentSubscriptionSummaryFromDict(data) {
+    const entitlementItems = (data.entitlement_items || []).map(hyperAgentEntitlementFromDict);
+    return {
+        effectivePlanId: data.effective_plan_id || '',
+        currentSubscriptionId: data.current_subscription_id || null,
+        currentEntitlementId: data.current_entitlement_id || data.current_subscription_id || null,
+        pooledTpmLimit: data.pooled_tpm_limit || 0,
+        pooledRpmLimit: data.pooled_rpm_limit || 0,
+        pooledTpd: data.pooled_tpd || 0,
+        slotInventory: data.slot_inventory || {},
+        billingResetAt: data.billing_reset_at ? new Date(String(data.billing_reset_at).replace('Z', '+00:00')) : null,
+        activeSubscriptionCount: data.active_subscription_count || 0,
+        activeEntitlementCount: data.active_entitlement_count || data.active_subscription_count || 0,
+        entitlements: hyperAgentEntitlementsFromDict(data),
+        entitlementItems,
+        activeSubscriptions: (data.active_subscriptions || []).map(hyperAgentSubscriptionFromDict),
+        subscriptions: (data.subscriptions || []).map(hyperAgentSubscriptionFromDict),
+        user: data.user || {},
+        agentSlots: (data.agent_slots || []).map(agentSlotFromDict),
+    };
+}
+function hyperAgentModelFromDict(data) {
+    const caps = data.capabilities || {};
+    return {
+        id: data.id,
+        name: data.name || data.id,
+        contextLength: data.context_length || 0,
+        supportsVision: caps.supports_vision || false,
+        supportsFunctionCalling: caps.supports_function_calling || false,
+        supportsToolChoice: caps.supports_tool_choice || false,
+    };
+}
+function dateFromDict(value) {
+    return value ? new Date(String(value).replace('Z', '+00:00')) : null;
+}
+function hyperAgentUsageSummaryFromDict(data) {
+    return {
+        totalTokens: Number(data?.total_tokens || 0),
+        promptTokens: Number(data?.prompt_tokens || 0),
+        completionTokens: Number(data?.completion_tokens || 0),
+        requestCount: Number(data?.request_count || 0),
+        activeKeys: Number(data?.active_keys || 0),
+        currentTpm: Number(data?.current_tpm || 0),
+        currentRpm: Number(data?.current_rpm || 0),
+        period: String(data?.period || ''),
+    };
+}
+function hyperAgentUsageHistoryEntryFromDict(data) {
+    return {
+        date: String(data?.date || ''),
+        totalTokens: Number(data?.total_tokens || 0),
+        promptTokens: Number(data?.prompt_tokens || 0),
+        completionTokens: Number(data?.completion_tokens || 0),
+        requests: Number(data?.requests || 0),
+    };
+}
+function hyperAgentUsageHistoryFromDict(data) {
+    return {
+        history: (data?.history || []).map(hyperAgentUsageHistoryEntryFromDict),
+        days: Number(data?.days || 0),
+    };
+}
+function hyperAgentKeyUsageEntryFromDict(data) {
+    return {
+        keyHash: String(data?.key_hash || ''),
+        name: String(data?.name || ''),
+        totalTokens: Number(data?.total_tokens || 0),
+        promptTokens: Number(data?.prompt_tokens || 0),
+        completionTokens: Number(data?.completion_tokens || 0),
+        requests: Number(data?.requests || 0),
+    };
+}
+function hyperAgentKeyUsageFromDict(data) {
+    return {
+        keys: (data?.keys || []).map(hyperAgentKeyUsageEntryFromDict),
+        days: Number(data?.days || 0),
+    };
+}
+function hyperAgentUsageMetricsFromDict(data) {
+    return {
+        totalTokens: Number(data?.total_tokens || 0),
+        promptTokens: Number(data?.prompt_tokens || 0),
+        completionTokens: Number(data?.completion_tokens || 0),
+        requests: Number(data?.requests || 0),
+    };
+}
+function hyperAgentAgentUsageFromDict(data) {
+    return {
+        agents: (data?.agents || []).map((entry) => ({
+            agentId: String(entry?.agent_id || ''),
+            name: String(entry?.name || ''),
+            managed: Boolean(entry?.managed),
+            avatarUrl: entry?.avatar_url || null,
+            ...hyperAgentUsageMetricsFromDict(entry),
+        })),
+        unattributed: hyperAgentUsageMetricsFromDict(data?.unattributed),
+        days: Number(data?.days || 0),
+    };
+}
+function hyperAgentTypeCatalogFromDict(data) {
+    return {
+        types: (data?.types || []).map((item) => ({
+            id: String(item?.id || ''),
+            name: String(item?.name || ''),
+            cpu: Number(item?.cpu || 0),
+            memory: Number(item?.memory || 0),
+        })),
+        plans: (data?.plans || []).map((item) => ({
+            id: String(item?.id || ''),
+            name: String(item?.name || ''),
+            price: Number(item?.price || 0),
+            agents: Number(item?.agents || 0),
+            agentType: String(item?.agent_type || ''),
+            highlighted: Boolean(item?.highlighted),
+        })),
+    };
+}
+function hyperAgentBillingProfileFieldsFromDict(data) {
+    return {
+        billingName: data?.billing_name ?? null,
+        billingCompany: data?.billing_company ?? null,
+        billingTaxId: data?.billing_tax_id ?? null,
+        billingLine1: data?.billing_line1 ?? null,
+        billingLine2: data?.billing_line2 ?? null,
+        billingCity: data?.billing_city ?? null,
+        billingState: data?.billing_state ?? null,
+        billingPostalCode: data?.billing_postal_code ?? null,
+        billingCountry: data?.billing_country ?? null,
+    };
+}
+function hyperAgentBillingProfileFieldsToDict(data) {
+    return {
+        billing_name: data.billingName,
+        billing_company: data.billingCompany,
+        billing_tax_id: data.billingTaxId,
+        billing_line1: data.billingLine1,
+        billing_line2: data.billingLine2,
+        billing_city: data.billingCity,
+        billing_state: data.billingState,
+        billing_postal_code: data.billingPostalCode,
+        billing_country: data.billingCountry,
+    };
+}
+function hyperAgentBillingInfoFromDict(data) {
+    return {
+        address: Array.isArray(data?.address) ? data.address.map(String) : [],
+        email: String(data?.email || ''),
+    };
+}
+function hyperAgentBillingProfileResponseFromDict(data) {
+    return {
+        companyBilling: hyperAgentBillingInfoFromDict(data?.company_billing || {}),
+        profile: data?.profile ? hyperAgentBillingProfileFieldsFromDict(data.profile) : null,
+        syncedStripeCustomerIds: Array.isArray(data?.synced_stripe_customer_ids) ? data.synced_stripe_customer_ids.map(String) : undefined,
+    };
+}
+function hyperAgentPaymentFromDict(data) {
+    return {
+        id: String(data?.id || ''),
+        userId: String(data?.user_id || ''),
+        subscriptionId: data?.subscription_id ?? null,
+        entitlementId: data?.entitlement_id ?? null,
+        provider: String(data?.provider || ''),
+        status: String(data?.status || ''),
+        amount: String(data?.amount || ''),
+        currency: String(data?.currency || ''),
+        externalPaymentId: data?.external_payment_id ?? null,
+        createdAt: dateFromDict(data?.created_at),
+        updatedAt: dateFromDict(data?.updated_at),
+        user: data?.user ? {
+            id: String(data.user.id || ''),
+            email: data.user.email ?? null,
+            walletAddress: data.user.wallet_address ?? null,
+            teamId: data.user.team_id ?? null,
+            planId: data.user.plan_id ?? null,
+            billingName: data.user.billing_name ?? null,
+            billingCompany: data.user.billing_company ?? null,
+            billingTaxId: data.user.billing_tax_id ?? null,
+            billingLine1: data.user.billing_line1 ?? null,
+            billingLine2: data.user.billing_line2 ?? null,
+            billingCity: data.user.billing_city ?? null,
+            billingState: data.user.billing_state ?? null,
+            billingPostalCode: data.user.billing_postal_code ?? null,
+            billingCountry: data.user.billing_country ?? null,
+        } : null,
+        subscription: data?.subscription ? {
+            id: String(data.subscription.id || ''),
+            planId: String(data.subscription.plan_id || ''),
+            provider: String(data.subscription.provider || ''),
+            status: String(data.subscription.status || ''),
+            currentPeriodEnd: dateFromDict(data.subscription.current_period_end),
+            stripeSubscriptionId: data.subscription.stripe_subscription_id ?? null,
+        } : null,
+        entitlement: data?.entitlement ? {
+            id: String(data.entitlement.id || ''),
+            planId: String(data.entitlement.plan_id || ''),
+            provider: String(data.entitlement.provider || ''),
+            status: String(data.entitlement.status || ''),
+            expiresAt: dateFromDict(data.entitlement.expires_at),
+            agentTier: data.entitlement.agent_tier ?? null,
+            features: data.entitlement.features || {},
+            tags: Array.isArray(data.entitlement.tags) ? data.entitlement.tags.map(String) : [],
+        } : null,
+    };
+}
+function hyperAgentPaymentsResponseFromDict(data) {
+    return {
+        items: (data?.items || []).map(hyperAgentPaymentFromDict),
+    };
+}
+function hyperAgentGrantRedemptionResponseFromDict(data) {
+    return {
+        grant: hyperAgentGrantFromDict(data?.grant || {}),
+        entitlement: hyperAgentEntitlementFromDict(data?.entitlement || {}),
+        ...(data?.payment ? { payment: hyperAgentPaymentFromDict(data.payment) } : {}),
+    };
+}
+function hyperAgentStripeCheckoutResponseFromDict(data) {
+    return {
+        checkoutUrl: String(data?.checkout_url || ''),
+        checkoutSessionId: data?.session_id ? String(data.session_id) : null,
+        checkoutAttemptId: data?.checkout_attempt_id ? String(data.checkout_attempt_id) : null,
+    };
+}
+function hyperAgentStripeBillingPortalSessionResponseFromDict(data) {
+    return {
+        id: data?.id ? String(data.id) : null,
+        url: String(data?.url || ''),
+    };
+}
+function hyperAgentX402CheckoutResponseFromDict(data) {
+    return {
+        ok: Boolean(data?.ok),
+        key: String(data?.key || ''),
+        planId: String(data?.plan_id || ''),
+        quantity: Number(data?.quantity || 0),
+        bundle: data?.bundle || {},
+        amountPaid: String(data?.amount_paid || ''),
+        durationDays: Number(data?.duration_days || 0),
+        expiresAt: dateFromDict(data?.expires_at),
+        tpmLimit: Number(data?.tpm_limit || 0),
+        rpmLimit: Number(data?.rpm_limit || 0),
+    };
+}
+/**
+ * HyperAgent API Client
+ *
+ * For chat completions, use the OpenAI Node.js SDK directly:
+ *
+ * ```typescript
+ * import OpenAI from 'openai';
+ *
+ * const openai = new OpenAI({
+ *   apiKey: client.agent.apiKey,
+ *   baseURL: client.agent.baseUrl,
+ * });
+ * ```
+ */
+export class HyperAgent {
+    static AGENT_API_BASE = 'https://api.hypercli.com/v1';
+    static DEV_API_BASE = 'https://api.dev.hypercli.com/v1';
+    apiKey;
+    baseUrl;
+    controlBaseUrl;
+    constructor(http, agentApiKey, dev = false, agentsApiBaseUrl) {
+        this.apiKey = agentApiKey || http['apiKey'];
+        const productBaseUrl = typeof http['baseUrl'] === 'string' ? http['baseUrl'] : getApiUrl();
+        const configuredBaseUrl = agentsApiBaseUrl || getAgentsApiBaseUrl(dev, productBaseUrl);
+        this.baseUrl = resolveHyperAgentBaseUrl(productBaseUrl);
+        this.controlBaseUrl = resolveHyperAgentControlBaseUrl(http['baseUrl'], configuredBaseUrl, dev);
+    }
+    get baseUrlWithoutV1() {
+        return this.baseUrl.replace(/\/v1$/, '');
+    }
+    async controlGet(path, params) {
+        const url = new URL(`${this.controlBaseUrl}${path}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        const response = await fetch(url.toString(), {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to GET ${path}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async controlPost(path, body) {
+        const url = `${this.controlBaseUrl}${path}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body ?? {}),
+        });
+        if (!response.ok) {
+            throw await responseAPIError(response, 'POST', url);
+        }
+        return response.json();
+    }
+    async controlPut(path, body) {
+        const response = await fetch(`${this.controlBaseUrl}${path}`, {
+            method: 'PUT',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body ?? {}),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to PUT ${path}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async plans() {
+        const response = await fetch(`${this.controlBaseUrl}/plans`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get plans: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return (data.plans || []).map(hyperAgentPlanFromDict);
+    }
+    async currentPlan() {
+        const response = await fetch(`${this.controlBaseUrl}/plans/current`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get current plan: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return hyperAgentCurrentPlanFromDict(data);
+    }
+    async subscriptions() {
+        const response = await fetch(`${this.controlBaseUrl}/subscriptions`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get subscriptions: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return (data.items || []).map(hyperAgentSubscriptionFromDict);
+    }
+    async subscriptionSummary() {
+        const response = await fetch(`${this.controlBaseUrl}/subscriptions/summary`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get subscription summary: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return hyperAgentSubscriptionSummaryFromDict(data);
+    }
+    async entitlements() {
+        const response = await fetch(`${this.controlBaseUrl}/entitlements`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get entitlements: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return hyperAgentSubscriptionSummaryFromDict(data);
+    }
+    async cancelSubscription(subscriptionId) {
+        const response = await fetch(`${this.controlBaseUrl}/subscriptions/${subscriptionId}/cancel`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get entitlements: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            ok: Boolean(data.ok),
+            message: data.message || '',
+            subscription: data.subscription ? hyperAgentSubscriptionFromDict(data.subscription) : undefined,
+        };
+    }
+    async updateSubscription(subscriptionId, request) {
+        const normalizedSubscriptionId = subscriptionId.trim();
+        const planId = request.planId.trim();
+        const quantity = request.quantity ?? 1;
+        if (!normalizedSubscriptionId) {
+            throw new Error('subscriptionId is required');
+        }
+        if (!planId) {
+            throw new Error('planId is required');
+        }
+        if (!Number.isInteger(quantity) || quantity < 1) {
+            throw new Error('quantity must be a positive integer');
+        }
+        const response = await fetch(`${this.controlBaseUrl}/subscriptions/${encodeURIComponent(normalizedSubscriptionId)}/update`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                plan_id: planId,
+                quantity,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to update subscription: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            ok: Boolean(data.ok),
+            message: data.message || '',
+            subscription: data.subscription ? hyperAgentSubscriptionFromDict(data.subscription) : undefined,
+        };
+    }
+    async models() {
+        const response = await fetch(`${this.baseUrl}/models`, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get models: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return (data.data || []).map((model) => hyperAgentModelFromDict({
+            id: model.id,
+            name: model.name || model.id,
+            context_length: model.context_length || 0,
+            capabilities: model.capabilities || {},
+        }));
+    }
+    async discoveryHealth() {
+        const response = await fetch(`${this.baseUrlWithoutV1}/discovery/health`);
+        if (!response.ok) {
+            throw new Error(`Failed to get discovery health: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    async discoveryConfig(apiKey) {
+        const headers = {};
+        if (apiKey) {
+            headers['X-API-KEY'] = apiKey;
+        }
+        const response = await fetch(`${this.baseUrlWithoutV1}/discovery/config`, {
+            headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get discovery config: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    async usageSummary() {
+        return hyperAgentUsageSummaryFromDict(await this.controlGet('/usage'));
+    }
+    async usageHistory(days = 7) {
+        return hyperAgentUsageHistoryFromDict(await this.controlGet('/usage/history', { days }));
+    }
+    async keyUsage(days = 7) {
+        return hyperAgentKeyUsageFromDict(await this.controlGet('/usage/keys', { days }));
+    }
+    async agentUsage(days = 1) {
+        return hyperAgentAgentUsageFromDict(await this.controlGet('/usage/agents', { days }));
+    }
+    async usageReport(days = 7) {
+        const clamped = Math.min(Math.max(Math.trunc(days) || 7, 1), 90);
+        const attempt = (promise) => promise.catch(() => null);
+        const [history, keys, agents] = await Promise.all([
+            attempt(this.usageHistory(clamped)),
+            attempt(this.keyUsage(clamped)),
+            attempt(this.agentUsage(clamped)),
+        ]);
+        return {
+            days: clamped,
+            history: history?.history ?? null,
+            keys: keys?.keys ?? null,
+            agents: agents?.agents ?? null,
+            unattributed: agents?.unattributed ?? null,
+        };
+    }
+    async agentTypes() {
+        return hyperAgentTypeCatalogFromDict(await this.controlGet('/types'));
+    }
+    async billingInfo() {
+        const data = await this.controlGet('/billing/info');
+        return hyperAgentBillingInfoFromDict(data?.company_billing || {});
+    }
+    async billingProfile() {
+        return hyperAgentBillingProfileResponseFromDict(await this.controlGet('/billing/profile'));
+    }
+    async updateBillingProfile(profile) {
+        return hyperAgentBillingProfileResponseFromDict(await this.controlPut('/billing/profile', hyperAgentBillingProfileFieldsToDict(profile)));
+    }
+    async payments(options = {}) {
+        const params = {};
+        if (options.limit !== undefined)
+            params.limit = options.limit;
+        if (options.provider)
+            params.provider = options.provider;
+        if (options.status)
+            params.status = options.status;
+        return hyperAgentPaymentsResponseFromDict(await this.controlGet('/billing/payments', params));
+    }
+    async payment(paymentId) {
+        return hyperAgentPaymentFromDict(await this.controlGet(`/billing/payments/${encodeURIComponent(paymentId)}`));
+    }
+    async billingHistory() {
+        const [subscriptions, payments] = await Promise.all([
+            this.subscriptions(),
+            this.payments({ limit: 1 }),
+        ]);
+        const subscriptionCount = subscriptions.length;
+        const paymentCount = payments.items.length;
+        return {
+            hasBillingHistory: subscriptionCount > 0 || paymentCount > 0,
+            subscriptionCount,
+            paymentCount,
+        };
+    }
+    async purchaseEntitlementFromBalance(planId, request) {
+        return hyperAgentGrantRedemptionResponseFromDict(await this.controlPost(`/billing/balance/${encodeURIComponent(planId)}`, {
+            duration: request.duration,
+            ...(request.tags ? { tags: request.tags } : {}),
+            ...(request.extendExisting !== undefined ? { extend_existing: Boolean(request.extendExisting) } : {}),
+        }));
+    }
+    async redeemGrantCode(code, request = {}) {
+        return hyperAgentGrantRedemptionResponseFromDict(await this.controlPost('/billing/grants/redeem', {
+            code,
+            ...(request.extendExisting !== undefined ? { extend_existing: Boolean(request.extendExisting) } : {}),
+        }));
+    }
+    async createStripeCheckout(request = {}, planId) {
+        if (request.bundle != null) {
+            throw new Error('Arbitrary slot bundles are no longer supported; purchase a canonical plan');
+        }
+        const payload = {
+            ...(request.successUrl ? { success_url: request.successUrl } : {}),
+            ...(request.cancelUrl ? { cancel_url: request.cancelUrl } : {}),
+            ...(request.quantity !== undefined ? { quantity: request.quantity } : {}),
+        };
+        const path = planId ? `/stripe/${encodeURIComponent(planId)}` : '/stripe/checkout';
+        return hyperAgentStripeCheckoutResponseFromDict(await this.controlPost(path, payload));
+    }
+    /**
+     * Create the account's one-time Team trial checkout.
+     *
+     * Maps to `POST {agentsBase}/stripe/trial` and returns a Stripe `checkout_url`.
+     */
+    async createStripeTrialCheckout(options = {}) {
+        return hyperAgentStripeCheckoutResponseFromDict(await this.controlPost('/stripe/trial', {
+            ...(options.successUrl !== undefined ? { success_url: options.successUrl } : {}),
+            ...(options.cancelUrl !== undefined ? { cancel_url: options.cancelUrl } : {}),
+        }));
+    }
+    async createStripeBillingPortalSession(request) {
+        return hyperAgentStripeBillingPortalSessionResponseFromDict(await this.controlPost('/stripe/billing-portal', {
+            return_url: request.returnUrl,
+            flow_data: { type: request.flowType },
+        }));
+    }
+    async purchaseViaX402(planId, request = {}) {
+        if (request.bundle != null) {
+            throw new Error('Arbitrary slot bundles are no longer supported; purchase a canonical plan');
+        }
+        const payload = {
+            ...(request.quantity !== undefined ? { quantity: request.quantity } : {}),
+        };
+        return hyperAgentX402CheckoutResponseFromDict(await this.controlPost(`/x402/${encodeURIComponent(planId)}`, payload));
+    }
+    async purchaseBundleViaX402(_request = {}) {
+        throw new Error('Arbitrary slot bundles are no longer supported; purchase a solo, team, or pro plan');
+    }
+    async createX402Checkout(_request = {}) {
+        throw new Error('A canonical plan ID is required; use purchaseViaX402(planId, request)');
+    }
+}
+//# sourceMappingURL=agent.js.map