Function bodies 108 total

async function main(): Promise<void> {
  const sdk = new HybrIQSDK({
    mode: "cloud",
    apiKey: process.env.HYBRIQ_API_KEY!,
    baseUrl: process.env.HYBRIQ_BASE_URL!,
    providers: {
      anthropic: { apiKey: process.env.ANTHROPIC_API_KEY! },
    },
  });

  console.log("SDK mode:", sdk.mode);

  // --- Check balance ---
  const balance = await sdk.getBalance();
  console.log(`Credits: ${balance.creditBalance} (${balance.plan} plan)`);

  // --- Execute an LLM call ---
  try {
    const result = await sdk.execute({
      model: "claude-sonnet-4-5-20250929",
      messages: [
        { role: "user", content: "What are the three laws of robotics?" },
      ],
      maxTokens: 256,
    });

    console.log("\n--- Response ---");
    console.log(result.response);
    console.log(`\nCache hit: ${result.cacheHit}`);
    console.log(`Tokens: ${result.tokensIn} in / ${result.tokensOut} out`);
    console.log(`Credits charged: ${result.creditsCharged}`);
  } catch (err) {
    if (err ins

async function main(): Promise<void> {
  const sdk = new HybrIQSDK({
    mode: "local",
    licenseKey: process.env.HYBRIQ_LICENSE_KEY!,
    providers: {
      anthropic: { apiKey: process.env.ANTHROPIC_API_KEY! },
    },
    cache: {
      semanticMatch: true,
      embeddingProvider: "local",  // Offline TF-IDF, no API needed
      semanticThreshold: 0.92,
    },
  });

  console.log("SDK mode:", sdk.mode);

  // --- Execute first call (cache miss) ---
  try {
    console.log("\n--- First call (cache miss expected) ---");
    const result1 = await sdk.execute({
      model: "claude-sonnet-4-5-20250929",
      messages: [
        { role: "user", content: "Explain what a neural network is in simple terms." },
      ],
      maxTokens: 256,
    });

    console.log(result1.response.slice(0, 200) + "...");
    console.log(`Cache hit: ${result1.cacheHit}`);

    // --- Execute same call again (exact cache hit) ---
    console.log("\n--- Second call (exact cache hit expected) ---");
    co

export class AgentsModule {
  constructor(private client: HybrIQApiClient) {}


  /**
   * Execute an agent with the given messages.
   *
   * @param agentId - The agent to execute.
   * @param request - Messages, optional webhook/stream/metadata.
   * @returns Typed execution result with response, cost, and cache info.
   *
   * @example
   * ```ts
   * const result = await sdk.agents.run("agent-id", {
   *   messages: [{ role: "user", content: "Summarize this document" }],
   * });
   * console.log(result.response.content);
   * ```
   */
  async run(
    agentId: string,
    request: AgentRunRequest
  ): Promise<AgentExecutionResult> {
    const { messages, webhook, stream, metadata, version } = request;

    const extraHeaders: Record<string, string> = {};
    if (version) {
      extraHeaders["X-Agent-Version"] = version;
    }

    const body = {
      messages,
      ...(webhook ? { webhook } : {}),
      ...(stream !== undefined ? { stream } : {}),
      ...(metadata ? { metada

  async run(
    agentId: string,
    request: AgentRunRequest
  ): Promise<AgentExecutionResult> {
    const { messages, webhook, stream, metadata, version } = request;

    const extraHeaders: Record<string, string> = {};
    if (version) {
      extraHeaders["X-Agent-Version"] = version;
    }

    const body = {
      messages,
      ...(webhook ? { webhook } : {}),
      ...(stream !== undefined ? { stream } : {}),
      ...(metadata ? { metadata } : {}),
    };

    const { data, headers } = await this.client.postWithHeaders<AgentExecutionResult>(
      `/api/v1/agents/${encodeURIComponent(agentId)}/run`,
      body,
      Object.keys(extraHeaders).length > 0 ? extraHeaders : undefined
    );

    // Populate cacheHit from X-Cache header if not already set
    if (data.response && headers.get("X-Cache")) {
      data.response.cacheHit = headers.get("X-Cache") === "HIT";
    }

    return data;
  }

export async function getBalance(
  apiClient: HybrIQApiClient
): Promise<BalanceInfo> {
  return apiClient.get<BalanceInfo>("/api/v1/billing/balance");
}

export async function getPlans(
  apiClient: HybrIQApiClient
): Promise<PlanInfo[]> {
  return apiClient.get<PlanInfo[]>("/api/v1/billing/plans");
}

export async function getUsage(
  apiClient: HybrIQApiClient,
  period?: "current" | "previous"
): Promise<UsageReport> {
  const params: Record<string, string> = {};
  if (period) params.period = period;
  return apiClient.get<UsageReport>("/api/v1/billing/usage", params);
}

export class HybrIQApiClient {
  /** @internal */
  readonly apiKey: string;
  /** @internal */
  readonly baseUrl: string;

  constructor(config: { apiKey: string; baseUrl: string }) {
    this.apiKey = config.apiKey;
    this.baseUrl = config.baseUrl.replace(/\/$/, "");
  }

  /**
   * POST request to the HybrIQ API.
   */
  async post<T = unknown>(path: string, body: unknown, extraHeaders?: Record<string, string>): Promise<T> {
    const { data } = await this.request<T>("POST", path, body, extraHeaders);
    return data;
  }

  /**
   * POST request returning both data and response headers.
   */
  async postWithHeaders<T = unknown>(path: string, body: unknown, extraHeaders?: Record<string, string>): Promise<{ data: T; headers: Headers }> {
    return this.request<T>("POST", path, body, extraHeaders);
  }

  /**
   * GET request to the HybrIQ API.
   */
  async get<T = unknown>(
    path: string,
    params?: Record<string, string>
  ): Promise<T> {
    let url = path;
    if (param

  constructor(config: { apiKey: string; baseUrl: string }) {
    this.apiKey = config.apiKey;
    this.baseUrl = config.baseUrl.replace(/\/$/, "");
  }

  async post<T = unknown>(path: string, body: unknown, extraHeaders?: Record<string, string>): Promise<T> {
    const { data } = await this.request<T>("POST", path, body, extraHeaders);
    return data;
  }

  async get<T = unknown>(
    path: string,
    params?: Record<string, string>
  ): Promise<T> {
    let url = path;
    if (params) {
      const searchParams = new URLSearchParams(params);
      url = `${path}?${searchParams.toString()}`;
    }
    const { data } = await this.request<T>("GET", url);
    return data;
  }

  private async request<T>(
    method: string,
    path: string,
    body?: unknown,
    extraHeaders?: Record<string, string>,
    attempt = 0
  ): Promise<{ data: T; headers: Headers }> {

function usd(amount: number): string {
  return `$${amount.toFixed(2)}`;
}

function pct(value: number): string {
  return `${(value * 100).toFixed(1)}%`;
}

function bar(value: number, max: number, width: number = 20): string {
  const filled = max > 0 ? Math.round((value / max) * width) : 0;
  const empty = width - filled;
  return `${c.green}${"█".repeat(filled)}${c.dim}${"░".repeat(empty)}${c.reset}`;
}

async function main(): Promise<void> {
  const baseDir = process.cwd();
  const configDir = join(baseDir, ".hybriq");

  console.log("");
  console.log(`${c.bold}${c.bgBlue}${c.white} HybrIQ Local Stats ${c.reset}`);
  console.log(`${c.dim}─────────────────────────────────────────${c.reset}`);

  // Check if .hybriq exists
  if (!existsSync(configDir)) {
    console.log(`${c.yellow}No .hybriq/ directory found in ${baseDir}${c.reset}`);
    console.log(`${c.dim}Run your first execution to initialize local mode.${c.reset}`);
    console.log("");
    process.exit(0);
  }

  // === Cache Stats ===
  const cacheDbPath = join(configDir, "cache.db");
  if (existsSync(cacheDbPath)) {
    const cache = new LocalCache(cacheDbPath);
    await cache.init();
    const stats = cache.getStats();
    cache.close();

    console.log("");
    console.log(`${c.bold}${c.cyan}Cache Performance${c.reset}`);
    console.log(`${c.dim}──────────────────${c.reset}`);

    const total = stats.totalHits + stats.t

export async function enrich(
  apiClient: HybrIQApiClient,
  request: EnrichRequest,
  providerCallback?: (req: EnrichRequest) => Promise<Record<string, unknown>>
): Promise<EnrichResult> {
  // First call: check cache
  const response = await apiClient.post<EnrichResponse>("/api/v1/enrich", {
    entityType: request.entityType,
    lookupKey: request.lookupKey,
    provider: request.provider,
    enrichedData: request.enrichedData,
    isolateTenant: request.isolateTenant,
  });

  if (response.cacheHit || response.data) {
    return {
      cacheHit: response.cacheHit,
      data: response.data,
      provider: response.provider ?? request.provider,
      confidence: response.confidence,
      creditsCharged: response.creditsCharged ?? 0,
      executionId: response.executionId,
    };
  }

  // Cache miss without data -- call provider if callback provided
  if (providerCallback && !request.enrichedData) {
    const enrichedData = await providerCallback(request);

    // Second call

function resolveProvider(model: string): "anthropic" | "openai" {
  if (model.startsWith("claude")) return "anthropic";
  if (model.startsWith("gpt")) return "openai";
  // Default to anthropic
  return "anthropic";
}

export async function execute(
  apiClient: HybrIQApiClient,
  providers: { anthropic?: ProviderConfig; openai?: ProviderConfig },
  request: ExecuteRequest
): Promise<ExecuteResult> {
  const providerName = resolveProvider(request.model);
  const providerConfig = providers[providerName];

  // Step 1: Try to start execution via HybrIQ API
  let startResponse: StartResponse;
  try {
    startResponse = await apiClient.post<StartResponse>(
      "/api/v1/execute/start",
      {
        executionType: "llm_call",
        modelProvider: providerName,
        modelName: request.model,
        systemPrompt: request.systemPrompt,
        messages: request.messages,
        agentId: request.agentId,
        skillId: request.skillId,
        shareable: request.shareable ?? false,
        metadata: request.metadata,
      }
    );
  } catch (err) {
    // Check if this is a network error (API unreachable)
    const hybriqErr = err as HybrIQError;
    if (hybriqErr.statusCode === 0 && hybriqErr.

async function executeDegraded(
  providerName: "anthropic" | "openai",
  providerConfig: ProviderConfig | undefined,
  request: ExecuteRequest
): Promise<ExecuteResult> {
  console.warn("HybrIQ unreachable — running in degraded mode");

  if (!providerConfig) {
    throw new Error(
      `No ${providerName} provider configured and HybrIQ API is unreachable.`
    );
  }

  const llmRequest: LLMRequest = {
    model: request.model,
    systemPrompt: request.systemPrompt,
    messages: request.messages,
    maxTokens: request.maxTokens,
    temperature: request.temperature,
  };

  const llmResponse =
    providerName === "anthropic"
      ? await callAnthropic(providerConfig, llmRequest)
      : await callOpenAI(providerConfig, llmRequest);

  return {
    executionId: "degraded",
    response: llmResponse.content,
    cacheHit: false,
    tokensIn: llmResponse.tokensIn,
    tokensOut: llmResponse.tokensOut,
    creditsCharged: 0,
    remainingCredits: -1,
    modelProvider: llmResponse

export class HybrIQSDK {
  private apiClient!: HybrIQApiClient;
  private providers: {
    anthropic?: ProviderConfig;
    openai?: ProviderConfig;
  };
  private readonly _mode: "cloud" | "local";
  private _license: ValidatedLicense | null = null;
  private _localCache: LocalCache | null = null;
  private _localMetering: LocalMetering | null = null;
  private _localConfig: LocalConfig | null = null;
  private _localInitPromise: Promise<void> | null = null;

  /** Browse and subscribe to the federated library (cloud mode only). */
  readonly library!: LibraryModule;

  /** Execute agents via the agent endpoint (cloud mode only). */
  readonly agents!: AgentsModule;

  constructor(config: HybrIQConfig) {
    this._mode = config.mode ?? "cloud";
    this.providers = config.providers ?? {};

    if (this._mode === "cloud") {
      if (!config.apiKey) {
        throw new Error("Cloud mode requires an API key. Provide `apiKey` in config.");
      }
      if (config.apiKey.startsWith("hiq_o

  constructor(config: HybrIQConfig) {
    this._mode = config.mode ?? "cloud";
    this.providers = config.providers ?? {};

    if (this._mode === "cloud") {
      if (!config.apiKey) {
        throw new Error("Cloud mode requires an API key. Provide `apiKey` in config.");
      }
      if (config.apiKey.startsWith("hiq_oss_")) {
        throw new Error(
          "OSS license keys are for local mode only. Use a tenant API key for cloud mode."
        );
      }
      if (!config.baseUrl) {
        throw new Error("Cloud mode requires a base URL. Provide `baseUrl` in config.");
      }
      this.apiClient = new HybrIQApiClient({
        apiKey: config.apiKey,
        baseUrl: config.baseUrl,
      });
      this.library = new LibraryModule(this.apiClient);
      this.agents = new AgentsModule(this.apiClient);
    } else if (this._mode === "local") {
      if (!config.licenseKey) {
        throw new Error("Local mode requires a license key. Provide `licenseKey` in config.");
      }
 

  private async initLocalMode(licenseKey: string, config: HybrIQConfig): Promise<void> {
    this._license = await validateLicense(licenseKey);

    // Configure semantic cache
    const semanticConfig = config.cache?.semanticMatch
      ? {
          enabled: true,
          embedding: {
            provider: (config.cache.embeddingProvider ?? "local") as "local" | "openai",
            apiKey: config.providers?.openai?.apiKey,
            threshold: config.cache.semanticThreshold ?? 0.92,
          },
        }
      : { enabled: false };

    this._localCache = new LocalCache(".hybriq/cache.db", semanticConfig);
    this._localMetering = new LocalMetering();
    this._localConfig = loadLocalConfig(this._license);
    await this._localCache.init();
    await this._localMetering.init();
  }

  private async ensureLocalInit(): Promise<void> {
    if (this._localInitPromise) {
      await this._localInitPromise;
      this._localInitPromise = null;
    }
  }

  async execute(request: ExecuteRequest): Promise<ExecuteResult> {
    if (this._mode === "local") {
      await this.ensureLocalInit();
      return executeLocal(
        request,
        this.providers,
        this._license!,
        this._localCache!,
        this._localMetering!
      );
    }
    return execute(this.apiClient, this.providers, request);
  }

  async usage(period?: "current" | "all"): Promise<LocalUsageReport> {
    if (this._mode !== "local") {
      throw new Error("usage() is only available in local mode.");
    }
    await this.ensureLocalInit();
    return this._localMetering!.getUsage(period ?? "current");
  }

  async export(outputPath: string, options?: ExportOptions): Promise<void> {
    if (this._mode !== "local") {
      throw new Error("export() is only available in local mode.");
    }
    await this.ensureLocalInit();
    return exportPack(outputPath, this._license!, this._localCache!, options);
  }

  async getBalance(): Promise<BalanceInfo> {
    this.requireCloud("getBalance");
    return getBalance(this.apiClient);
  }

  async getPlans(): Promise<PlanInfo[]> {
    this.requireCloud("getPlans");
    return getPlans(this.apiClient);
  }

  async getUsage(period?: "current" | "previous"): Promise<UsageReport> {
    this.requireCloud("getUsage");
    return getUsage(this.apiClient, period);
  }

  async enrich(
    request: EnrichRequest,
    providerCallback?: (req: EnrichRequest) => Promise<Record<string, unknown>>
  ): Promise<EnrichResult> {
    this.requireCloud("enrich");
    return enrich(this.apiClient, request, providerCallback);
  }

  async getLocalConfig(): Promise<LocalConfig> {
    if (this._mode !== "local") {
      throw new Error("getLocalConfig() is only available in local mode.");
    }
    await this.ensureLocalInit();
    return this._localConfig!;
  }

  async getLocalAgent(agentId: string): Promise<LocalAgentConfig | undefined> {
    const config = await this.getLocalConfig();
    return getAgent(config, agentId);
  }

  async getLocalSkill(skillId: string): Promise<LocalSkillConfig | undefined> {
    const config = await this.getLocalConfig();
    return getSkill(config, skillId);
  }

  static scaffold(baseDir?: string): void {
    scaffoldConfig(baseDir);
  }

  private requireCloud(method: string): void {
    if (this._mode !== "cloud") {
      throw new Error(`${method}() is only available in cloud mode.`);
    }
  }

export class LibraryModule {
  constructor(private apiClient: HybrIQApiClient) {}

  async browseAgents(params?: { category?: string; search?: string }): Promise<LibraryItem[]> {
    const query: Record<string, string> = {};
    if (params?.category) query.category = params.category;
    if (params?.search) query.search = params.search;
    return this.apiClient.get<LibraryItem[]>("/api/v1/library/agents", query);
  }

  async browseSkills(params?: { category?: string }): Promise<LibraryItem[]> {
    const query: Record<string, string> = {};
    if (params?.category) query.category = params.category;
    return this.apiClient.get<LibraryItem[]>("/api/v1/library/skills", query);
  }

  async browseSpecialties(params?: { domain?: string }): Promise<LibraryItem[]> {
    const query: Record<string, string> = {};
    if (params?.domain) query.domain = params.domain;
    return this.apiClient.get<LibraryItem[]>("/api/v1/library/specialties", query);
  }

  async browseClusters(): Promise<Lib

  async browseAgents(params?: { category?: string; search?: string }): Promise<LibraryItem[]> {
    const query: Record<string, string> = {};
    if (params?.category) query.category = params.category;
    if (params?.search) query.search = params.search;
    return this.apiClient.get<LibraryItem[]>("/api/v1/library/agents", query);
  }

  async browseSkills(params?: { category?: string }): Promise<LibraryItem[]> {
    const query: Record<string, string> = {};
    if (params?.category) query.category = params.category;
    return this.apiClient.get<LibraryItem[]>("/api/v1/library/skills", query);
  }

  async browseSpecialties(params?: { domain?: string }): Promise<LibraryItem[]> {
    const query: Record<string, string> = {};
    if (params?.domain) query.domain = params.domain;
    return this.apiClient.get<LibraryItem[]>("/api/v1/library/specialties", query);
  }

  async browseClusters(): Promise<LibraryItem[]> {
    return this.apiClient.get<LibraryItem[]>("/api/v1/library/clusters");
  }

  async subscribe(itemType: string, itemId: string, overrides?: Record<string, unknown>): Promise<SubscriptionInfo> {
    return this.apiClient.post<SubscriptionInfo>("/api/v1/library/subscribe", {
      itemType,
      itemId,
      configOverrides: overrides,
    });
  }

  async unsubscribe(subscriptionId: string): Promise<void> {
    await this.apiClient.delete(`/api/v1/library/subscribe/${subscriptionId}`);
  }

  async listSubscriptions(): Promise<SubscriptionInfo[]> {
    return this.apiClient.get<SubscriptionInfo[]>("/api/v1/library/subscriptions");
  }

export class InvalidLicenseError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "InvalidLicenseError";
  }
}

  constructor(message: string) {
    super(message);
    this.name = "InvalidLicenseError";
  }

export async function validateLicense(
  licenseKey: string
): Promise<ValidatedLicense> {
  // Check prefix
  if (!licenseKey.startsWith("hiq_oss_")) {
    throw new InvalidLicenseError(
      "Invalid license key format. Expected prefix 'hiq_oss_'."
    );
  }

  // Decode base64url payload
  const base64Part = licenseKey.slice("hiq_oss_".length);
  let combined: Uint8Array;
  try {
    combined = Uint8Array.from(Buffer.from(base64Part, "base64url"));
  } catch {
    throw new InvalidLicenseError("Invalid license key encoding.");
  }

  if (combined.length <= SIGNATURE_LENGTH) {
    throw new InvalidLicenseError(
      "License key is too short — missing payload or signature."
    );
  }

  // Split payload and signature
  const payloadBytes = combined.slice(0, combined.length - SIGNATURE_LENGTH);
  const signature = combined.slice(combined.length - SIGNATURE_LENGTH);

  // Verify Ed25519 signature
  const publicKeyBytes = Uint8Array.from(Buffer.from(PUBLIC_KEY, "base64"));
  let val

export function checkFeatureAccess(
  license: ValidatedLicense,
  feature: "agent" | "skill",
  currentCount: number
): boolean {
  const { entitlements } = license.payload;

  if (feature === "agent") {
    // -1 means unlimited
    if (entitlements.maxAgents === -1) return true;
    return currentCount < entitlements.maxAgents;
  }

  if (feature === "skill") {
    if (entitlements.maxSkills === -1) return true;
    return currentCount < entitlements.maxSkills;
  }

  return false;
}

export class LocalCache {
  private db: Database | null = null;
  private dbPath: string;
  private hits = 0;
  private misses = 0;
  private semanticHits = 0;
  private exactHits = 0;
  private estimatedSavingsUsd = 0;
  private semanticConfig: SemanticCacheConfig;

  constructor(
    dbPath: string = ".hybriq/cache.db",
    semanticConfig?: SemanticCacheConfig
  ) {
    this.dbPath = dbPath;
    this.semanticConfig = semanticConfig ?? { enabled: false };
  }

  /**
   * Initialize the SQLite database.
   * Creates cache tables (exact + semantic) if they don't exist.
   */
  async init(): Promise<void> {
    const SQL = await initSqlJs();

    const dir = dirname(this.dbPath);
    if (!existsSync(dir)) {
      mkdirSync(dir, { recursive: true });
    }

    if (existsSync(this.dbPath)) {
      const buffer = readFileSync(this.dbPath);
      this.db = new SQL.Database(buffer);
    } else {
      this.db = new SQL.Database();
    }

    // Exact match table
    this.db.run(`
      CREAT

  constructor(
    dbPath: string = ".hybriq/cache.db",
    semanticConfig?: SemanticCacheConfig
  ) {
    this.dbPath = dbPath;
    this.semanticConfig = semanticConfig ?? { enabled: false };
  }