@rawdash/connector-vertex-ai 0.22.0

package/dist/index.js

@@ -0,0 +1,1080 @@
+// ../gcp-shared/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+var serviceAccountKeySchema = z.object({
+  client_email: z.string().min(1),
+  private_key: z.string().min(1),
+  token_uri: z.string().url().optional(),
+  project_id: z.string().optional()
+});
+var tokenResponseSchema = z.object({
+  access_token: z.string().min(1),
+  expires_in: z.number().int().positive().optional()
+});
+function base64urlFromBytes(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64urlFromString(str) {
+  return base64urlFromBytes(new TextEncoder().encode(str));
+}
+async function signRS256JWT(payload, privateKeyPem) {
+  const header = { alg: "RS256", typ: "JWT" };
+  const headerB64 = base64urlFromString(JSON.stringify(header));
+  const payloadB64 = base64urlFromString(JSON.stringify(payload));
+  const signingInput = `${headerB64}.${payloadB64}`;
+  const pemContent = privateKeyPem.replace(/-----BEGIN PRIVATE KEY-----/g, "").replace(/-----END PRIVATE KEY-----/g, "").replace(/\s/g, "");
+  const der = Uint8Array.from(atob(pemContent), (c) => c.charCodeAt(0));
+  const key = await globalThis.crypto.subtle.importKey(
+    "pkcs8",
+    der,
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await globalThis.crypto.subtle.sign(
+    "RSASSA-PKCS1-v1_5",
+    key,
+    new TextEncoder().encode(signingInput)
+  );
+  return `${signingInput}.${base64urlFromBytes(new Uint8Array(signature))}`;
+}
+function parseServiceAccountJson(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{")) {
+    return serviceAccountKeySchema.parse(JSON.parse(trimmed));
+  }
+  const binary = atob(trimmed);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  const decoded = new TextDecoder().decode(bytes);
+  return serviceAccountKeySchema.parse(JSON.parse(decoded));
+}
+async function buildServiceAccountJwt(serviceAccountJson, scope) {
+  const sa = parseServiceAccountJson(serviceAccountJson);
+  const now = Math.floor(Date.now() / 1e3);
+  const jwt = await signRS256JWT(
+    {
+      iss: sa.client_email,
+      scope,
+      aud: sa.token_uri ?? "https://oauth2.googleapis.com/token",
+      exp: now + 3600,
+      iat: now
+    },
+    sa.private_key
+  );
+  const body = new URLSearchParams({
+    grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+    assertion: jwt
+  }).toString();
+  return {
+    url: sa.token_uri ?? "https://oauth2.googleapis.com/token",
+    body
+  };
+}
+function buildRefreshTokenGrant(credentials) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: credentials.refreshToken,
+    client_id: credentials.clientId,
+    client_secret: credentials.clientSecret
+  }).toString();
+  return { url: "https://oauth2.googleapis.com/token", body };
+}
+var gcpAuthConfigShape = {
+  serviceAccountJson: z2.object({ $secret: z2.string().trim().min(1) }).meta({
+    label: "Service Account JSON",
+    description: "Contents of the JSON key file for a Google service account with the role required by this connector. Create one at Google Cloud -> IAM & Admin -> Service Accounts and store the JSON as a secret.",
+    secret: true
+  })
+};
+var HttpClientError = class extends Error {
+  response;
+  constructor(message, response) {
+    super(message);
+    this.name = new.target.name;
+    this.response = response;
+  }
+};
+var AuthError = class extends HttpClientError {
+  kind = "auth";
+};
+var HTTP_CLIENT_VERSION = "0.0.0";
+var DEFAULT_USER_AGENT = `rawdash-connector/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
+function parseEpoch(value, unit) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (unit === "iso") {
+    if (typeof value !== "string") {
+      return null;
+    }
+    const ms = new Date(value).getTime();
+    return Number.isFinite(ms) ? ms : null;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return null;
+  }
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) {
+    return null;
+  }
+  const result = unit === "s" ? n * 1e3 : n;
+  return Number.isFinite(result) ? result : null;
+}
+var BQ_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+var BQ_DATASET_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var BQ_API_BASE = "https://bigquery.googleapis.com/bigquery/v2";
+var BQ_READONLY_SCOPE = "https://www.googleapis.com/auth/bigquery.readonly";
+var BQ_PAGE_SIZE = 1e4;
+var BQ_QUERY_TIMEOUT_MS = 3e4;
+var bqQueryResponseSchema = z3.object({
+  jobComplete: z3.boolean().optional(),
+  schema: z3.object({
+    fields: z3.array(z3.object({ name: z3.string(), type: z3.string() }))
+  }).optional(),
+  rows: z3.array(
+    z3.object({
+      f: z3.array(z3.object({ v: z3.string().nullable().optional() }))
+    })
+  ).optional(),
+  pageToken: z3.string().optional(),
+  jobReference: z3.object({
+    projectId: z3.string(),
+    jobId: z3.string(),
+    location: z3.string().optional()
+  }).optional()
+});
+function buildBigQueryPageRequest(opts) {
+  const pageSize = opts.pageSize ?? BQ_PAGE_SIZE;
+  const timeoutMs = opts.timeoutMs ?? BQ_QUERY_TIMEOUT_MS;
+  if (opts.pageToken === void 0) {
+    const url2 = `${BQ_API_BASE}/projects/${encodeURIComponent(
+      opts.projectId
+    )}/queries`;
+    const body = {
+      query: opts.sql,
+      useLegacySql: false,
+      maxResults: pageSize,
+      timeoutMs
+    };
+    if (opts.location !== void 0) {
+      body["location"] = opts.location;
+    }
+    return { method: "POST", url: url2, body: JSON.stringify(body) };
+  }
+  if (opts.jobReference === void 0) {
+    throw new Error(
+      "cannot fetch the next page of BigQuery results without a jobReference"
+    );
+  }
+  const params = new URLSearchParams({
+    pageToken: opts.pageToken,
+    maxResults: String(pageSize),
+    timeoutMs: String(timeoutMs)
+  });
+  const location = opts.jobReference.location ?? opts.location;
+  if (location !== void 0) {
+    params.set("location", location);
+  }
+  const url = `${BQ_API_BASE}/projects/${encodeURIComponent(
+    opts.jobReference.projectId
+  )}/queries/${encodeURIComponent(opts.jobReference.jobId)}?${params.toString()}`;
+  return { method: "GET", url };
+}
+async function collectBigQueryPages(opts) {
+  const rows = [];
+  let pageToken;
+  let jobReference;
+  let page = 0;
+  const phaseStart = Date.now();
+  do {
+    if (opts.signal?.aborted) {
+      return { rows, aborted: true };
+    }
+    const request = buildBigQueryPageRequest({
+      projectId: opts.projectId,
+      sql: opts.sql,
+      pageToken,
+      jobReference,
+      location: opts.location,
+      pageSize: opts.pageSize
+    });
+    let response;
+    try {
+      response = await opts.fetchPage(request, opts.signal);
+    } catch (err) {
+      opts.logger?.warn("fetch page failed", {
+        resource: opts.resource,
+        page: page + 1,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+    if (response.jobComplete === false) {
+      throw new Error(opts.jobIncompleteMessage);
+    }
+    if (response.jobReference !== void 0) {
+      jobReference = response.jobReference;
+    }
+    const pageRows = opts.mapRows(response);
+    rows.push(...pageRows);
+    pageToken = typeof response.pageToken === "string" && response.pageToken.length > 0 ? response.pageToken : void 0;
+    page += 1;
+    opts.logger?.info("fetched page", {
+      resource: opts.resource,
+      page,
+      items: pageRows.length,
+      next: pageToken ?? null
+    });
+  } while (pageToken !== void 0);
+  opts.logger?.info("resource done", {
+    resource: opts.resource,
+    pages: page,
+    items: rows.length,
+    duration_ms: Date.now() - phaseStart
+  });
+  return { rows, aborted: false };
+}
+function indexBqFields(response) {
+  const fieldIndex = {};
+  (response.schema?.fields ?? []).forEach((field, idx) => {
+    fieldIndex[field.name] = idx;
+  });
+  return fieldIndex;
+}
+function readBqCell(cells, fieldIndex, name) {
+  const idx = fieldIndex[name];
+  if (idx === void 0) {
+    return null;
+  }
+  const raw = cells[idx]?.v;
+  if (raw === void 0 || raw === null) {
+    return null;
+  }
+  return raw;
+}
+function parseBqDateOrEpoch(value) {
+  const dateMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (dateMatch) {
+    return Date.UTC(
+      Number(dateMatch[1]),
+      Number(dateMatch[2]) - 1,
+      Number(dateMatch[3])
+    );
+  }
+  return parseEpoch(value, "iso");
+}
+var GcpAccessTokenProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  cached = null;
+  async resolveGrant() {
+    const serviceAccountJson = this.opts.getServiceAccountJson();
+    if (serviceAccountJson) {
+      return buildServiceAccountJwt(serviceAccountJson, this.opts.scope);
+    }
+    const refreshTokenCredentials = this.opts.getRefreshTokenCredentials?.();
+    if (refreshTokenCredentials) {
+      return buildRefreshTokenGrant(refreshTokenCredentials);
+    }
+    throw new AuthError(
+      `${this.opts.connectorId}: missing serviceAccountJson or refresh-token credentials`
+    );
+  }
+  async getToken(signal) {
+    if (this.cached && Date.now() < this.cached.expiresAt) {
+      return this.cached.token;
+    }
+    const { url, body } = await this.resolveGrant();
+    const res = await this.opts.post(url, {
+      resource: "oauth_token",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body,
+      signal
+    });
+    const expiresIn = res.body.expires_in ?? 3600;
+    this.cached = {
+      token: res.body.access_token,
+      expiresAt: Date.now() + (expiresIn - 60) * 1e3
+    };
+    return this.cached.token;
+  }
+};
+var MS_PER_DAY = 864e5;
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function toDateStr(ms) {
+  const d = new Date(ms);
+  return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+}
+function startOfUtcDay(ms) {
+  return Math.floor(ms / MS_PER_DAY) * MS_PER_DAY;
+}
+
+// ../../connector-shared/dist/index.js
+var HTTP_CLIENT_VERSION2 = "0.0.0";
+var DEFAULT_USER_AGENT2 = `rawdash-connector/${HTTP_CLIENT_VERSION2} (+https://rawdash.dev)`;
+function connectorUserAgent(connectorId) {
+  return `rawdash-connector-${connectorId}/${HTTP_CLIENT_VERSION2} (+https://rawdash.dev)`;
+}
+function parseEpoch2(value, unit) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (unit === "iso") {
+    if (typeof value !== "string") {
+      return null;
+    }
+    const ms = new Date(value).getTime();
+    return Number.isFinite(ms) ? ms : null;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return null;
+  }
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) {
+    return null;
+  }
+  const result = unit === "s" ? n * 1e3 : n;
+  return Number.isFinite(result) ? result : null;
+}
+
+// src/vertex-ai.ts
+import {
+  BaseConnector,
+  defineConfigFields,
+  defineConnectorDoc,
+  defineResources,
+  makeChunkedCursorGuard,
+  schemasFromResources
+} from "@rawdash/core";
+import { z as z4 } from "zod";
+var configFields = defineConfigFields(
+  z4.object({
+    projectId: z4.string().regex(BQ_IDENT_RE, "projectId must be a valid GCP project id").meta({
+      label: "GCP project ID",
+      description: "Google Cloud project ID that hosts the Vertex AI workload. Cloud Monitoring metrics are read from this project.",
+      placeholder: "my-project-123"
+    }),
+    ...gcpAuthConfigShape,
+    bqProject: z4.string().regex(BQ_IDENT_RE, "bqProject must be a valid GCP project id").optional().meta({
+      label: "BigQuery project ID (optional)",
+      description: "Project that hosts the Cloud Billing -> BigQuery export. Required to sync the spend resource; omit to disable spend syncing.",
+      placeholder: "my-billing-project"
+    }),
+    bqDataset: z4.string().regex(
+      BQ_DATASET_RE,
+      "bqDataset must be a valid BigQuery dataset id (letters, digits, underscores; must start with a letter or underscore)"
+    ).optional().meta({
+      label: "BigQuery dataset (optional)",
+      description: "BigQuery dataset containing the Cloud Billing export tables (gcp_billing_export_v1_*). Required to sync the spend resource.",
+      placeholder: "billing_export"
+    }),
+    bqLocation: z4.string().min(1).optional().meta({
+      label: "BigQuery location (optional)",
+      description: "Region or multi-region of the billing dataset (e.g. US, EU, us-central1). Defaults to US when bqDataset is set.",
+      placeholder: "US"
+    }),
+    spendServiceFilter: z4.string().min(1).optional().meta({
+      label: "Spend service filter (optional)",
+      description: 'BigQuery LIKE pattern matched against service.description to scope spend rows to Vertex AI. Defaults to "Vertex AI%" which covers both "Vertex AI" and "Vertex AI Generative AI" services.',
+      placeholder: "Vertex AI%"
+    }),
+    lookbackDays: z4.number().int().positive().max(365).optional().meta({
+      label: "Backfill window (days)",
+      description: "How many days of history to pull on a full sync. Defaults to 30.",
+      placeholder: "30"
+    })
+  })
+);
+var doc = defineConnectorDoc({
+  displayName: "Google Cloud Vertex AI",
+  category: "engineering",
+  brandColor: "#4285F4",
+  tagline: "Sync daily Vertex AI model invocations, token counts, errors, and spend (Gemini and partner models) into a single dashboard view of GCP AI usage.",
+  vendor: {
+    name: "Google Cloud",
+    domain: "cloud.google.com",
+    apiDocs: "https://cloud.google.com/vertex-ai/docs/general/monitoring",
+    website: "https://cloud.google.com/vertex-ai"
+  },
+  auth: {
+    summary: "Authenticate against the Cloud Monitoring v3 API (and optionally BigQuery for spend) with a Google service account JSON key. The service account needs the Monitoring Viewer role on the project running Vertex AI. To sync spend, it additionally needs BigQuery Data Viewer on the billing dataset and BigQuery Job User on the billing project.",
+    setup: [
+      "Identify the GCP project running Vertex AI (it owns the publisher/online_serving metrics).",
+      "Create a service account at Google Cloud -> IAM & Admin -> Service Accounts in that project (or grant an existing one access).",
+      "Grant the service account the Monitoring Viewer role (roles/monitoring.viewer) on the project so it can read Vertex AI metrics.",
+      "To sync spend, enable the Cloud Billing -> BigQuery export (Billing -> Billing export -> BigQuery export). Then grant the service account roles/bigquery.dataViewer on the export dataset and roles/bigquery.jobUser on the bqProject.",
+      "Generate a JSON key for the service account and store its contents as a secret (e.g. GCP_SA_JSON).",
+      'Reference the key from config as serviceAccountJson: secret("GCP_SA_JSON") and set projectId to the Vertex AI project. Set bqProject / bqDataset to enable the spend resource.'
+    ]
+  },
+  rateLimit: "Cloud Monitoring projects.timeSeries.list and BigQuery jobs.query are rate-limited per project; 429 / RESOURCE_EXHAUSTED responses are retried with backoff. Each sync issues at most three requests (invocations metric, tokens metric, optional BigQuery query).",
+  limitations: [
+    "Only the publisher (Gemini and partner online-serving) metric family is synced. Custom model deployments under aiplatform.googleapis.com/prediction/* are out of scope; query Cloud Monitoring directly via the gcp-monitoring connector if you need them.",
+    "Spend rows come from the Cloud Billing -> BigQuery export; the export must be configured manually in the GCP console and only days after the configuration date are present.",
+    "BigQuery cost rows are back-revised by GCP for several days; an incremental sync refetches a short trailing window to pick up corrections.",
+    "Each BigQuery query is billed against the bqProject; keep lookbackDays reasonable.",
+    "Daily aggregation only - sub-day granularity is intentionally not exposed for spend or invocation rollups."
+  ]
+});
+var vertexAiCredentials = {
+  serviceAccountJson: {
+    description: "Google service account JSON key (raw JSON or base64)",
+    auth: "required"
+  }
+};
+var int64String = z4.string().regex(/^-?\d+$/);
+var isoTimestamp = z4.iso.datetime();
+var pointValue = z4.object({
+  doubleValue: z4.number().optional(),
+  int64Value: int64String.optional(),
+  boolValue: z4.boolean().optional(),
+  stringValue: z4.string().optional(),
+  distributionValue: z4.unknown().optional()
+}).refine(
+  (v) => v.doubleValue !== void 0 || v.int64Value !== void 0 || v.boolValue !== void 0 || v.stringValue !== void 0 || v.distributionValue !== void 0,
+  {
+    message: "point value must carry at least one supported value field"
+  }
+);
+var pointSchema = z4.object({
+  interval: z4.object({
+    startTime: isoTimestamp.optional(),
+    endTime: isoTimestamp
+  }),
+  value: pointValue
+});
+var timeSeriesSchema = z4.object({
+  metric: z4.object({
+    type: z4.string(),
+    labels: z4.record(z4.string(), z4.string()).optional()
+  }),
+  resource: z4.object({
+    type: z4.string().optional(),
+    labels: z4.record(z4.string(), z4.string()).optional()
+  }).optional(),
+  valueType: z4.string().optional(),
+  metricKind: z4.string().optional(),
+  points: z4.array(pointSchema).optional()
+});
+var listTimeSeriesResponseSchema = z4.object({
+  timeSeries: z4.array(timeSeriesSchema).optional(),
+  nextPageToken: z4.string().optional()
+});
+var INVOCATIONS_METRIC_NAME = "vertex_ai_invocations";
+var ERRORS_METRIC_NAME = "vertex_ai_errors";
+var TOKENS_METRIC_NAME = "vertex_ai_tokens";
+var SPEND_METRIC_NAME = "vertex_ai_spend";
+var INVOCATION_COUNT_TYPE = "aiplatform.googleapis.com/publisher/online_serving/model_invocation_count";
+var TOKEN_COUNT_TYPE = "aiplatform.googleapis.com/publisher/online_serving/token_count";
+var vertexAiResources = defineResources({
+  [INVOCATIONS_METRIC_NAME]: {
+    shape: "metric",
+    description: "Daily count of successful Vertex AI model invocations (HTTP 2xx) per (date, modelId). Sourced from the Cloud Monitoring metric `aiplatform.googleapis.com/publisher/online_serving/model_invocation_count`, aggregated to one sample per day with SUM.",
+    endpoint: "GET /v3/projects/{projectId}/timeSeries",
+    granularity: "daily",
+    notes: "On every sync the trailing `lookbackDays` window is rewritten idempotently. Non-2xx response codes flow to `vertex_ai_errors` instead.",
+    dimensions: [
+      {
+        name: "modelId",
+        description: "Vertex AI publisher model identifier, e.g. gemini-1.5-pro or text-bison."
+      },
+      {
+        name: "responseCode",
+        description: "Upstream HTTP response code reported by Vertex AI (always 2xx in this resource)."
+      }
+    ],
+    responses: {
+      oauth_token: tokenResponseSchema,
+      invocations: listTimeSeriesResponseSchema
+    }
+  },
+  [ERRORS_METRIC_NAME]: {
+    shape: "metric",
+    description: "Daily count of failed Vertex AI model invocations (non-2xx) per (date, modelId, errorType). Sourced from the same Cloud Monitoring API call as `vertex_ai_invocations`; rows with response_code outside 200-299 are routed here.",
+    endpoint: "GET /v3/projects/{projectId}/timeSeries (shared with vertex_ai_invocations)",
+    granularity: "daily",
+    notes: "errorType carries the upstream HTTP status (e.g. 400, 429, 500). Use it to slice quota errors (429) from request errors (4xx) and platform errors (5xx). The response schema is registered under `vertex_ai_invocations`.",
+    dimensions: [
+      {
+        name: "modelId",
+        description: "Vertex AI publisher model identifier."
+      },
+      {
+        name: "errorType",
+        description: "HTTP status code returned by Vertex AI (400, 401, 403, 429, 5xx, ...)."
+      }
+    ]
+  },
+  [TOKENS_METRIC_NAME]: {
+    shape: "metric",
+    description: "Daily Vertex AI token usage per (date, modelId, tokenType). Sourced from the Cloud Monitoring metric `aiplatform.googleapis.com/publisher/online_serving/token_count`. tokenType is either `input` (prompt) or `output` (completion).",
+    endpoint: "GET /v3/projects/{projectId}/timeSeries",
+    granularity: "daily",
+    notes: "Sum across both tokenType values to get total tokens; slice by tokenType to separate input from output cost drivers.",
+    dimensions: [
+      {
+        name: "modelId",
+        description: "Vertex AI publisher model identifier."
+      },
+      {
+        name: "tokenType",
+        description: "Either `input` (prompt tokens) or `output` (response tokens)."
+      }
+    ],
+    responses: {
+      tokens: listTimeSeriesResponseSchema
+    }
+  },
+  [SPEND_METRIC_NAME]: {
+    shape: "metric",
+    description: "Daily Vertex AI spend per (date, sku) sourced from the Cloud Billing -> BigQuery export. Skipped unless bqProject and bqDataset are configured.",
+    endpoint: "POST /bigquery/v2/projects/{bqProject}/queries",
+    unit: "USD",
+    granularity: "daily",
+    notes: 'The trailing 5 days are always refetched on incremental syncs to pick up GCP back-revisions. SKU describes the specific Vertex AI model and token type (e.g. "Gemini 1.5 Pro Online Inference - Input").',
+    dimensions: [
+      {
+        name: "sku",
+        description: 'GCP SKU description, e.g. "Gemini 1.5 Pro Online Inference - Input Tokens".'
+      },
+      {
+        name: "service",
+        description: 'GCP service description, typically "Vertex AI" or "Vertex AI Generative AI".'
+      },
+      {
+        name: "currency",
+        description: "Billing currency reported by GCP."
+      }
+    ],
+    responses: {
+      spend: bqQueryResponseSchema
+    }
+  }
+});
+var PHASE_ORDER = ["invocations", "tokens", "spend"];
+var PHASE_TO_RESOURCES = {
+  invocations: [INVOCATIONS_METRIC_NAME, ERRORS_METRIC_NAME],
+  tokens: [TOKENS_METRIC_NAME],
+  spend: [SPEND_METRIC_NAME]
+};
+var isVertexAiCursor = makeChunkedCursorGuard(PHASE_ORDER);
+var MONITORING_API_BASE = "https://monitoring.googleapis.com/v3";
+var MONITORING_SCOPE = "https://www.googleapis.com/auth/monitoring.read";
+var MONITORING_PAGE_SIZE = 1e3;
+var DAILY_ALIGNMENT_SECONDS = 86400;
+var DAILY_ALIGNMENT = `${DAILY_ALIGNMENT_SECONDS}s`;
+var DEFAULT_LOOKBACK_DAYS = 30;
+var INCREMENTAL_LOOKBACK_DAYS = 5;
+var DEFAULT_SPEND_SERVICE_FILTER = "Vertex AI%";
+var id = "vertex-ai";
+var cost = {
+  recommendedInterval: "1 day",
+  minInterval: "1 hour",
+  perSync: "2 Cloud Monitoring requests, plus 1 BigQuery query when bqProject/bqDataset are set",
+  warning: "Each BigQuery spend query is billed against the bqProject. Prefer once-a-day syncs unless you need fresher invocation counts."
+};
+var VertexAiConnector = class _VertexAiConnector extends BaseConnector {
+  static id = id;
+  static resources = vertexAiResources;
+  static schemas = schemasFromResources(vertexAiResources);
+  static cost = cost;
+  static create(input, ctx) {
+    const parsed = configFields.parse(input);
+    return new _VertexAiConnector(
+      {
+        projectId: parsed.projectId,
+        bqProject: parsed.bqProject,
+        bqDataset: parsed.bqDataset,
+        bqLocation: parsed.bqLocation,
+        spendServiceFilter: parsed.spendServiceFilter,
+        lookbackDays: parsed.lookbackDays
+      },
+      { serviceAccountJson: parsed.serviceAccountJson },
+      ctx
+    );
+  }
+  id = id;
+  credentials = vertexAiCredentials;
+  monitoringTokenProvider;
+  bigQueryTokenProvider;
+  getMonitoringToken(signal) {
+    this.monitoringTokenProvider ??= new GcpAccessTokenProvider({
+      connectorId: this.id,
+      scope: MONITORING_SCOPE,
+      getServiceAccountJson: () => this.creds.serviceAccountJson,
+      post: (url, opts) => this.post(url, opts)
+    });
+    return this.monitoringTokenProvider.getToken(signal);
+  }
+  getBigQueryToken(signal) {
+    this.bigQueryTokenProvider ??= new GcpAccessTokenProvider({
+      connectorId: this.id,
+      scope: BQ_READONLY_SCOPE,
+      getServiceAccountJson: () => this.creds.serviceAccountJson,
+      post: (url, opts) => this.post(url, opts)
+    });
+    return this.bigQueryTokenProvider.getToken(signal);
+  }
+  async listTimeSeries(metricType, groupByFields, startMs, endMs, pageToken, resource, signal) {
+    const params = new URLSearchParams();
+    params.set("filter", `metric.type = "${metricType}"`);
+    params.set("interval.startTime", new Date(startMs).toISOString());
+    params.set("interval.endTime", new Date(endMs).toISOString());
+    params.set("aggregation.alignmentPeriod", DAILY_ALIGNMENT);
+    params.set("aggregation.perSeriesAligner", "ALIGN_SUM");
+    params.set("aggregation.crossSeriesReducer", "REDUCE_SUM");
+    for (const field of groupByFields) {
+      params.append("aggregation.groupByFields", field);
+    }
+    params.set("pageSize", String(MONITORING_PAGE_SIZE));
+    if (pageToken !== void 0) {
+      params.set("pageToken", pageToken);
+    }
+    const url = `${MONITORING_API_BASE}/projects/${encodeURIComponent(
+      this.settings.projectId
+    )}/timeSeries?${params.toString()}`;
+    const accessToken = await this.getMonitoringToken(signal);
+    const res = await this.get(
+      url,
+      {
+        resource,
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "User-Agent": connectorUserAgent(this.id)
+        },
+        signal
+      }
+    );
+    return res.body;
+  }
+  async fetchBigQueryPage(request, signal) {
+    const accessToken = await this.getBigQueryToken(signal);
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": connectorUserAgent(this.id)
+    };
+    if (request.method === "POST") {
+      const res2 = await this.post(request.url, {
+        resource: "spend",
+        headers,
+        body: request.body,
+        signal
+      });
+      return res2.body;
+    }
+    const res = await this.get(request.url, {
+      resource: "spend",
+      headers,
+      signal
+    });
+    return res.body;
+  }
+  async syncInvocations(storage, window, requestedResources, signal) {
+    const wantInvocations = !requestedResources || requestedResources.size === 0 || requestedResources.has(INVOCATIONS_METRIC_NAME);
+    const wantErrors = !requestedResources || requestedResources.size === 0 || requestedResources.has(ERRORS_METRIC_NAME);
+    if (!wantInvocations && !wantErrors) {
+      return;
+    }
+    const invocations = [];
+    const errors = [];
+    let pageToken;
+    let page = 0;
+    const phaseStart = Date.now();
+    do {
+      if (signal?.aborted) {
+        return;
+      }
+      let response;
+      try {
+        response = await this.listTimeSeries(
+          INVOCATION_COUNT_TYPE,
+          ["metric.labels.model_user_id", "metric.labels.response_code"],
+          window.startMs,
+          window.endMs,
+          pageToken,
+          "invocations",
+          signal
+        );
+      } catch (err) {
+        this.logger.warn("fetch page failed", {
+          resource: "invocations",
+          page: page + 1,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+      const series = response.timeSeries ?? [];
+      let pageItems = 0;
+      for (const ts of series) {
+        const modelId = ts.metric.labels?.["model_user_id"] ?? null;
+        const responseCode = ts.metric.labels?.["response_code"] ?? "";
+        const isError = !isSuccessCode(responseCode);
+        for (const point of ts.points ?? []) {
+          const sample = pointToCountSample(modelId, responseCode, point);
+          if (sample === null) {
+            continue;
+          }
+          if (isError) {
+            errors.push({
+              name: ERRORS_METRIC_NAME,
+              ts: sample.ts,
+              value: sample.value,
+              attributes: {
+                modelId: sample.attributes["modelId"] ?? null,
+                errorType: responseCode
+              }
+            });
+          } else {
+            invocations.push({
+              name: INVOCATIONS_METRIC_NAME,
+              ts: sample.ts,
+              value: sample.value,
+              attributes: sample.attributes
+            });
+          }
+          pageItems += 1;
+        }
+      }
+      pageToken = nextPageTokenOrUndefined(response.nextPageToken);
+      page += 1;
+      this.logger.info("fetched page", {
+        resource: "invocations",
+        page,
+        items: pageItems,
+        next: pageToken ?? null
+      });
+    } while (pageToken !== void 0);
+    if (wantInvocations) {
+      await storage.metrics(invocations, { names: [INVOCATIONS_METRIC_NAME] });
+    }
+    if (wantErrors) {
+      await storage.metrics(errors, { names: [ERRORS_METRIC_NAME] });
+    }
+    this.logger.info("resource done", {
+      resource: "invocations",
+      pages: page,
+      items: invocations.length + errors.length,
+      duration_ms: Date.now() - phaseStart
+    });
+  }
+  async syncTokens(storage, window, signal) {
+    const samples = [];
+    let pageToken;
+    let page = 0;
+    const phaseStart = Date.now();
+    do {
+      if (signal?.aborted) {
+        return;
+      }
+      let response;
+      try {
+        response = await this.listTimeSeries(
+          TOKEN_COUNT_TYPE,
+          ["metric.labels.model_user_id", "metric.labels.type"],
+          window.startMs,
+          window.endMs,
+          pageToken,
+          "tokens",
+          signal
+        );
+      } catch (err) {
+        this.logger.warn("fetch page failed", {
+          resource: "tokens",
+          page: page + 1,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+      const series = response.timeSeries ?? [];
+      let pageItems = 0;
+      for (const ts of series) {
+        const modelId = ts.metric.labels?.["model_user_id"] ?? null;
+        const tokenType = ts.metric.labels?.["type"] ?? ts.metric.labels?.["token_type"] ?? "";
+        for (const point of ts.points ?? []) {
+          const sample = pointToTokenSample(modelId, tokenType, point);
+          if (sample === null) {
+            continue;
+          }
+          samples.push(sample);
+          pageItems += 1;
+        }
+      }
+      pageToken = nextPageTokenOrUndefined(response.nextPageToken);
+      page += 1;
+      this.logger.info("fetched page", {
+        resource: "tokens",
+        page,
+        items: pageItems,
+        next: pageToken ?? null
+      });
+    } while (pageToken !== void 0);
+    await storage.metrics(samples, { names: [TOKENS_METRIC_NAME] });
+    this.logger.info("resource done", {
+      resource: "tokens",
+      pages: page,
+      items: samples.length,
+      duration_ms: Date.now() - phaseStart
+    });
+  }
+  async syncSpend(storage, window, signal) {
+    if (this.settings.bqProject === void 0 || this.settings.bqDataset === void 0) {
+      this.logger.info("resource done", {
+        resource: "spend",
+        pages: 0,
+        items: 0,
+        duration_ms: 0,
+        skipped: "bqProject or bqDataset not configured"
+      });
+      return;
+    }
+    const sql = buildVertexSpendSql({
+      bqProject: this.settings.bqProject,
+      bqDataset: this.settings.bqDataset,
+      startDate: window.startDate,
+      endDate: window.endDate,
+      serviceFilter: this.settings.spendServiceFilter ?? DEFAULT_SPEND_SERVICE_FILTER
+    });
+    const { rows: samples, aborted } = await collectBigQueryPages(
+      {
+        projectId: this.settings.bqProject,
+        sql,
+        resource: "spend",
+        location: this.settings.bqLocation,
+        signal,
+        logger: this.logger,
+        mapRows: (response) => buildSpendSamplesFromBqResponse(response),
+        jobIncompleteMessage: `${this.id}: BigQuery spend query did not complete within the synchronous timeout (jobComplete=false). Lower lookbackDays so the query finishes faster.`,
+        fetchPage: (request, sig) => this.fetchBigQueryPage(request, sig)
+      }
+    );
+    if (aborted) {
+      return;
+    }
+    await storage.metrics(samples, { names: [SPEND_METRIC_NAME] });
+  }
+  async sync(options, storage, signal) {
+    const lookbackDays = this.settings.lookbackDays ?? DEFAULT_LOOKBACK_DAYS;
+    const monitoringWindow = getMonitoringWindow(options, lookbackDays);
+    const spendWindow = getSpendWindow(options, lookbackDays);
+    const cursor = isVertexAiCursor(options.cursor) ? options.cursor : void 0;
+    const resumeIdx = cursor ? PHASE_ORDER.indexOf(cursor.phase) : 0;
+    const startIdx = resumeIdx >= 0 ? resumeIdx : 0;
+    for (let i = startIdx; i < PHASE_ORDER.length; i++) {
+      const phase = PHASE_ORDER[i];
+      if (signal?.aborted) {
+        return { done: false, cursor: { phase, page: null } };
+      }
+      if (options.resources && options.resources.size > 0 && !PHASE_TO_RESOURCES[phase].some((r) => options.resources.has(r))) {
+        continue;
+      }
+      try {
+        if (phase === "invocations") {
+          await this.syncInvocations(
+            storage,
+            monitoringWindow,
+            options.resources,
+            signal
+          );
+        } else if (phase === "tokens") {
+          await this.syncTokens(storage, monitoringWindow, signal);
+        } else {
+          await this.syncSpend(storage, spendWindow, signal);
+        }
+      } catch (err) {
+        if (signal?.aborted) {
+          return { done: false, cursor: { phase, page: null } };
+        }
+        throw err;
+      }
+    }
+    return { done: true };
+  }
+};
+function isSuccessCode(code) {
+  if (code.length === 0) {
+    return true;
+  }
+  const n = Number.parseInt(code, 10);
+  if (!Number.isFinite(n)) {
+    return false;
+  }
+  return n >= 200 && n < 300;
+}
+function nextPageTokenOrUndefined(token) {
+  if (typeof token === "string" && token.length > 0) {
+    return token;
+  }
+  return void 0;
+}
+function pointToCountSample(modelId, responseCode, point) {
+  const ts = parseEpoch2(point.interval.endTime, "iso");
+  if (ts === null) {
+    return null;
+  }
+  const value = extractScalarValue(point.value);
+  if (value === null) {
+    return null;
+  }
+  return {
+    ts,
+    value,
+    attributes: {
+      modelId: modelId ?? null,
+      responseCode
+    }
+  };
+}
+function pointToTokenSample(modelId, tokenType, point) {
+  const ts = parseEpoch2(point.interval.endTime, "iso");
+  if (ts === null) {
+    return null;
+  }
+  const value = extractScalarValue(point.value);
+  if (value === null) {
+    return null;
+  }
+  return {
+    name: TOKENS_METRIC_NAME,
+    ts,
+    value,
+    attributes: {
+      modelId: modelId ?? null,
+      tokenType
+    }
+  };
+}
+function extractScalarValue(v) {
+  if (v.doubleValue !== void 0 && Number.isFinite(v.doubleValue)) {
+    return v.doubleValue;
+  }
+  if (v.int64Value !== void 0) {
+    const n = Number(v.int64Value);
+    return Number.isSafeInteger(n) ? n : null;
+  }
+  if (v.boolValue !== void 0) {
+    return v.boolValue ? 1 : 0;
+  }
+  return null;
+}
+function getMonitoringWindow(options, lookbackDays, now = Date.now()) {
+  const endMs = startOfUtcDay(now) + MS_PER_DAY;
+  let days = lookbackDays;
+  if (options.mode === "latest") {
+    days = INCREMENTAL_LOOKBACK_DAYS;
+  } else if (options.since !== void 0) {
+    const sinceMs = parseEpoch2(options.since, "iso");
+    if (sinceMs !== null) {
+      const elapsed = Math.ceil((now - sinceMs) / MS_PER_DAY);
+      days = Math.min(
+        Math.max(elapsed + INCREMENTAL_LOOKBACK_DAYS, 1),
+        lookbackDays
+      );
+    }
+  }
+  return { startMs: endMs - days * MS_PER_DAY, endMs };
+}
+function getSpendWindow(options, lookbackDays, now = Date.now()) {
+  const endMs = startOfUtcDay(now) + MS_PER_DAY;
+  let days = lookbackDays;
+  if (options.mode === "latest") {
+    days = INCREMENTAL_LOOKBACK_DAYS;
+  } else if (options.since !== void 0) {
+    const sinceMs = parseEpoch2(options.since, "iso");
+    if (sinceMs !== null) {
+      const elapsed = Math.ceil((now - sinceMs) / MS_PER_DAY);
+      days = Math.min(
+        Math.max(elapsed + INCREMENTAL_LOOKBACK_DAYS, 1),
+        lookbackDays
+      );
+    }
+  }
+  return {
+    startDate: toDateStr(endMs - days * MS_PER_DAY),
+    endDate: toDateStr(endMs)
+  };
+}
+function buildVertexSpendSql(args) {
+  const escapedFilter = args.serviceFilter.replace(/'/g, "\\'");
+  const table = `\`${args.bqProject}.${args.bqDataset}.gcp_billing_export_v1_*\``;
+  return [
+    `SELECT DATE(usage_start_time) AS date,`,
+    `  service.description AS service,`,
+    `  sku.description AS sku,`,
+    `  SUM(cost) AS cost,`,
+    `  ANY_VALUE(currency) AS currency`,
+    `FROM ${table}`,
+    `WHERE DATE(usage_start_time) >= DATE('${args.startDate}')`,
+    `  AND DATE(usage_start_time) < DATE('${args.endDate}')`,
+    `  AND service.description LIKE '${escapedFilter}'`,
+    `GROUP BY date, service, sku`,
+    `ORDER BY date`
+  ].join("\n");
+}
+function buildSpendSamplesFromBqResponse(response) {
+  const fieldIndex = indexBqFields(response);
+  const samples = [];
+  for (const row of response.rows ?? []) {
+    const dateValue = readBqCell(row.f, fieldIndex, "date");
+    if (dateValue === null) {
+      continue;
+    }
+    const ts = parseBqDateOrEpoch(dateValue);
+    if (ts === null) {
+      continue;
+    }
+    const costValue = readBqCell(row.f, fieldIndex, "cost");
+    if (costValue === null) {
+      continue;
+    }
+    const value = Number.parseFloat(costValue);
+    if (!Number.isFinite(value)) {
+      continue;
+    }
+    const attributes = {
+      sku: readBqCell(row.f, fieldIndex, "sku") ?? null,
+      service: readBqCell(row.f, fieldIndex, "service") ?? null
+    };
+    const currency = readBqCell(row.f, fieldIndex, "currency");
+    if (currency !== null) {
+      attributes["currency"] = currency;
+    }
+    samples.push({ name: SPEND_METRIC_NAME, ts, value, attributes });
+  }
+  return samples;
+}
+
+// src/index.ts
+var index_default = VertexAiConnector;
+export {
+  ERRORS_METRIC_NAME,
+  INVOCATIONS_METRIC_NAME,
+  SPEND_METRIC_NAME,
+  TOKENS_METRIC_NAME,
+  VertexAiConnector,
+  buildSpendSamplesFromBqResponse,
+  buildVertexSpendSql,
+  configFields,
+  cost,
+  index_default as default,
+  doc,
+  getMonitoringWindow,
+  getSpendWindow,
+  id,
+  pointToCountSample,
+  pointToTokenSample,
+  vertexAiResources as resources
+};
+//# sourceMappingURL=index.js.map