deepline 0.3.306 → 0.3.308

package/dist/cli/{chunk-LLGF6V6I.mjs → chunk-HGI6RGHB.mjs}

@@ -14,7 +14,7 @@ import {
   RETAINED_PIPELINE_RECEIVERS_HEADER,
   RUNTIME_ENVIRONMENT_TOKEN_HEADER,
   resolveConfig
-} from "./chunk-4PSSDZQB.mjs";
+} from "./chunk-T3P4NRZU.mjs";
 import {
   PLAY_RUNTIME_BACKENDS,
   RAW_V2_TOOL_RESPONSE_CONTRACT,
@@ -562,11 +562,11 @@ function resolveLegacySlackNotification(destinations) {
   const slackDestinations = destinations.filter(
     (destination) => destination.kind === "slack" && destination.archivedAt === void 0
   );
-  const canonical = slackDestinations.filter(
+  const canonical2 = slackDestinations.filter(
     (destination) => destination.name === LEGACY_SLACK_NOTIFICATION_NAME
   );
-  if (canonical.length === 1) return canonical[0];
-  if (canonical.length > 1) {
+  if (canonical2.length === 1) return canonical2[0];
+  if (canonical2.length > 1) {
     throw new ProductNotificationLegacySelectionError(
       `More than one "${LEGACY_SLACK_NOTIFICATION_NAME}" Slack notification exists. Use the named notification API to choose one.`
     );
@@ -1223,6 +1223,7 @@ var RUN_EVENT_TERMINAL_KIND_VALUES = [
   RUN_EVENT_KIND.runCancelled
 ];
 var RUN_LOG_RETENTION_MAX_BYTES = 5 * 1024 * 1024;
+var RUN_LOG_LEVELS = ["debug", "info", "warn", "error"];
 function sqlStringLiteral(value) {
   return "'" + value.replaceAll("'", "''") + "'";
 }
@@ -2013,6 +2014,528 @@ function parseRunLogsCursor(value) {
   return parsed;
 }
 
+// ../play-runtime/run-event-query.ts
+var stringField = { type: "string", nullable: false };
+var optionalString = { type: "string", nullable: true };
+var RUN_EVENT_QUERY_FIELD_CATALOG = {
+  eventId: stringField,
+  orgId: stringField,
+  runtimeScope: stringField,
+  runId: stringField,
+  playName: stringField,
+  kind: stringField,
+  source: optionalString,
+  occurredAt: { type: "timestamp", nullable: false },
+  status: optionalString,
+  level: { type: "level", nullable: true },
+  stepId: optionalString,
+  stepKind: optionalString,
+  datasetId: optionalString,
+  phase: optionalString,
+  provider: optionalString,
+  operation: optionalString,
+  producerAttempt: { type: "number", nullable: true }
+};
+var RUN_EVENT_QUERY_RETENTION_MS = 7 * 864e5;
+var RUN_EVENT_QUERY_MAX_LIMIT = 200;
+var RUN_EVENT_QUERY_MAX_PAYLOAD_LIMIT = 10;
+var RUN_EVENT_QUERY_MAX_CURSOR_BYTES = 48 * 1024;
+var RUN_EVENT_QUERY_MAX_REQUEST_BYTES = 64 * 1024;
+var MAX_BYTES = 8192;
+var MAX_DEPTH = 8;
+var MAX_PREDICATES = 64;
+var OPERATORS = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "exists",
+  "in"
+];
+var RunEventQueryInputError = class extends TypeError {
+  constructor(message, code = "invalid_run_event_query") {
+    super(message);
+    this.code = code;
+    this.name = "RunEventQueryInputError";
+  }
+};
+function fail(message) {
+  throw new RunEventQueryInputError(message);
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function bounded(value, maxBytes = MAX_BYTES) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(value);
+  } catch {
+    fail("Run event query must be bounded JSON without cycles.");
+  }
+  if (!encoded || new TextEncoder().encode(encoded).length > maxBytes)
+    fail(`Run event query exceeds ${maxBytes} bytes.`);
+}
+function validateRunEventField(value) {
+  if (typeof value !== "string") fail("Run event field must be a string.");
+  const field = value.startsWith("$.") ? value.slice(2) : value;
+  if (Object.prototype.hasOwnProperty.call(RUN_EVENT_QUERY_FIELD_CATALOG, field))
+    return field;
+  if (/^context\.[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(field) && !["__proto__", "prototype", "constructor"].includes(field.slice(8)))
+    return field;
+  const alternatives = {
+    step: "stepId",
+    severity: "level",
+    timestamp: "occurredAt",
+    play: "playName",
+    run: "runId",
+    attempt: "producerAttempt"
+  };
+  fail(
+    `Unsupported run event field: ${field}. Use ${alternatives[field] ?? "a catalog field or context.<key>"}; call fields() for supported fields.`
+  );
+}
+function scalar(field, value, op) {
+  if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+    fail(`Run event ${field} requires a JSON scalar.`);
+  if (typeof value === "number" && !Number.isFinite(value))
+    fail(`Run event ${field} requires a finite number.`);
+  if (typeof value === "string" && new TextEncoder().encode(value).length > 1024)
+    fail(`Run event ${field} value exceeds 1024 bytes.`);
+  const descriptor = RUN_EVENT_QUERY_FIELD_CATALOG[field];
+  if (descriptor) {
+    if (value === null) {
+      if (!descriptor.nullable) fail(`Run event ${field} cannot be null.`);
+    } else if (descriptor.type === "number") {
+      if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+        fail(`Run event ${field} requires a positive integer.`);
+    } else if (typeof value !== "string")
+      fail(`Run event ${field} requires a string.`);
+    else if (descriptor.type === "level" && !RUN_LOG_LEVELS.includes(value))
+      fail("Run event level requires debug, info, warn or error.");
+    else if (descriptor.type === "timestamp") {
+      value = normalizeRunEventQueryTimestamp(value);
+    }
+  }
+  if (["gt", "gte", "lt", "lte"].includes(op) && (value === null || typeof value === "boolean"))
+    fail(`Run event ${op} requires a string or number.`);
+  return value;
+}
+function comparison(field, op, value) {
+  if (!OPERATORS.includes(op))
+    fail(`Unsupported run event operator: ${op}. Use ${OPERATORS.join(", ")}.`);
+  if (op === "exists") {
+    if (typeof value !== "boolean")
+      fail("Run event exists requires a boolean.");
+    return { field, op, value };
+  }
+  if (op === "in") {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 32)
+      fail("Run event in requires between 1 and 32 scalars.");
+    return { field, op, value: value.map((item) => scalar(field, item, "eq")) };
+  }
+  return {
+    field,
+    op,
+    value: scalar(field, value, op)
+  };
+}
+function admitObject(input, depth = 0, budget = { count: 0 }) {
+  if (depth > MAX_DEPTH) fail("Run event where exceeds depth 8.");
+  if (!object(input) || !Object.keys(input).length)
+    fail("Run event where requires a nonempty object.");
+  const terms = [];
+  const fieldTerms = (raw, filter) => {
+    const field = validateRunEventField(raw);
+    const operators = object(filter) ? Object.entries(filter) : [["eq", filter]];
+    if (!operators.length)
+      fail(`Run event ${field} has an empty operator object.`);
+    for (const [op, value] of operators) {
+      if (++budget.count > MAX_PREDICATES)
+        fail("Run event where exceeds 64 predicates.");
+      terms.push(comparison(field, op, value));
+    }
+  };
+  for (const [key, filter] of Object.entries(input)) {
+    if (key === "and" || key === "or") {
+      if (!Array.isArray(filter) || filter.length < 1 || filter.length > MAX_PREDICATES)
+        fail(`Run event ${key} requires a nonempty bounded array.`);
+      const children = filter.map(
+        (item) => admitObject(item, depth + 1, budget)
+      );
+      terms.push(key === "and" ? { and: children } : { or: children });
+    } else if (key === "context") {
+      if (!object(filter) || !Object.keys(filter).length)
+        fail("Run event context requires flat scalar fields.");
+      for (const [contextKey, value] of Object.entries(filter))
+        fieldTerms(`context.${contextKey}`, value);
+    } else fieldTerms(key, filter);
+  }
+  return terms.length === 1 ? terms[0] : { and: terms };
+}
+function compact(predicate) {
+  if ("and" in predicate) {
+    const merged = {};
+    for (const term of predicate.and) {
+      const child = compact(term);
+      for (const [key, value] of Object.entries(child)) {
+        if (key === "and") return { and: predicate.and.map(compact) };
+        if (key === "context") {
+          const context = merged.context ?? {};
+          for (const [name, filter2] of Object.entries(value)) {
+            if (Object.prototype.hasOwnProperty.call(context, name)) {
+              const combined = combineFilters(context[name], filter2);
+              if (!combined) return { and: predicate.and.map(compact) };
+              context[name] = combined;
+            } else context[name] = filter2;
+          }
+          merged.context = context;
+        } else if (Object.prototype.hasOwnProperty.call(merged, key)) {
+          const combined = key === "or" ? void 0 : combineFilters(merged[key], value);
+          if (!combined) return { and: predicate.and.map(compact) };
+          merged[key] = combined;
+        } else merged[key] = value;
+      }
+    }
+    return merged;
+  }
+  if ("or" in predicate) return { or: predicate.or.map(compact) };
+  const filter = predicate.op === "eq" ? predicate.value : { [predicate.op]: predicate.value };
+  if (predicate.field.startsWith("context."))
+    return { context: { [predicate.field.slice(8)]: filter } };
+  return { [predicate.field]: filter };
+}
+function combineFilters(left, right) {
+  const first = object(left) ? left : { eq: left };
+  const second = object(right) ? right : { eq: right };
+  if (Object.keys(first).some(
+    (key) => Object.prototype.hasOwnProperty.call(second, key)
+  ))
+    return void 0;
+  return { ...first, ...second };
+}
+function canonical(predicate) {
+  if ("field" in predicate) return predicate;
+  const operator = "and" in predicate ? "and" : "or";
+  const source = "and" in predicate ? predicate.and : predicate.or;
+  const terms = source.map(canonical).flatMap((term) => {
+    if (operator === "and" && "and" in term) return term.and;
+    if (operator === "or" && "or" in term) return term.or;
+    return [term];
+  });
+  terms.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+  const unique = terms.filter(
+    (term, i) => i === 0 || JSON.stringify(term) !== JSON.stringify(terms[i - 1])
+  );
+  if (unique.length === 1) return unique[0];
+  return operator === "and" ? { and: unique } : { or: unique };
+}
+function parseDsl(input) {
+  let position = 0;
+  let count = 0;
+  const skip = () => {
+    while (/\s/.test(input[position] ?? "") && position < input.length)
+      position++;
+  };
+  const take = (token) => {
+    skip();
+    if (input.startsWith(token, position)) {
+      position += token.length;
+      return true;
+    }
+    return false;
+  };
+  const json = () => {
+    skip();
+    const start = position;
+    if (input[position] === '"') {
+      position++;
+      let closed = false;
+      while (position < input.length) {
+        const char = input[position++];
+        if (char === "\\") position++;
+        else if (char === '"') {
+          closed = true;
+          break;
+        }
+      }
+      if (!closed) fail("Run event DSL has an unterminated JSON string.");
+    } else {
+      const match = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(
+        input.slice(position)
+      );
+      if (!match)
+        fail("Run event DSL requires a JSON quoted string or scalar.");
+      position += match[0].length;
+    }
+    try {
+      return JSON.parse(input.slice(start, position));
+    } catch {
+      fail("Run event DSL requires valid JSON scalars.");
+    }
+  };
+  const term = (depth) => {
+    if (depth > MAX_DEPTH) fail("Run event where exceeds depth 8.");
+    if (take("(")) {
+      const nested = or(depth + 1);
+      if (!take(")")) fail("Run event DSL is missing a closing parenthesis.");
+      return nested;
+    }
+    skip();
+    const match = /^(?:\$\.)?[A-Za-z_][A-Za-z0-9_.]*/.exec(
+      input.slice(position)
+    );
+    if (!match) fail("Run event DSL requires a supported field.");
+    position += match[0].length;
+    const field = validateRunEventField(match[0]);
+    if (++count > MAX_PREDICATES)
+      fail("Run event where exceeds 64 predicates.");
+    skip();
+    const operation = /^(==|!=|>=|<=|>|<|\b(?:eq|ne|gte|gt|lte|lt|in|exists)\b)/.exec(
+      input.slice(position)
+    );
+    if (!operation)
+      fail("Run event DSL requires a supported comparison operator.");
+    position += operation[0].length;
+    const symbols = {
+      "==": "eq",
+      "!=": "ne",
+      ">=": "gte",
+      "<=": "lte",
+      ">": "gt",
+      "<": "lt"
+    };
+    const op = symbols[operation[0]] ?? operation[0];
+    if (op === "in") {
+      if (!take("[")) fail("Run event DSL in requires a JSON scalar array.");
+      const values = [];
+      if (!take("]")) {
+        do {
+          values.push(json());
+          if (values.length > 32)
+            fail("Run event in requires between 1 and 32 scalars.");
+        } while (take(","));
+        if (!take("]")) fail("Run event DSL in requires a closing bracket.");
+      }
+      return comparison(field, op, values);
+    }
+    return comparison(field, op, json());
+  };
+  const and = (depth) => {
+    const terms = [term(depth)];
+    while (take("&&")) terms.push(term(depth));
+    return terms.length === 1 ? terms[0] : { and: terms };
+  };
+  const or = (depth) => {
+    const terms = [and(depth)];
+    while (take("||")) terms.push(and(depth));
+    return terms.length === 1 ? terms[0] : { or: terms };
+  };
+  const result = or(0);
+  skip();
+  if (position !== input.length)
+    fail(`Run event DSL has unsupported input at position ${position}.`);
+  return result;
+}
+function parseRunEventWhere(input) {
+  bounded(input);
+  const where = compact(
+    canonical(typeof input === "string" ? parseDsl(input) : admitObject(input))
+  );
+  bounded(where);
+  return where;
+}
+function normalizeRunEventQueryTimestamp(value) {
+  let extraMicros = "";
+  if (typeof value === "string") {
+    const timestamp = /^[+-]?\d{4,6}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.(\d{1,6}))?(?:Z|[+-]\d{2}:\d{2})$/.exec(
+      value
+    );
+    if (!timestamp)
+      fail(
+        "Run event time bounds require an ISO timestamp with a timezone and at most six fractional digits."
+      );
+    extraMicros = (timestamp[1] ?? "").padEnd(6, "0").slice(3);
+  }
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime()))
+    fail("Run event time bound is invalid.");
+  const canonical2 = date.toISOString();
+  return /[1-9]/.test(extraMicros) ? canonical2.replace(/Z$/, `${extraMicros}Z`) : canonical2;
+}
+function timestampMicros(value) {
+  const fraction = /\.(\d+)Z$/.exec(value)?.[1] ?? "";
+  return BigInt(Date.parse(value)) * BigInt(1e3) + BigInt(fraction.padEnd(6, "0").slice(3));
+}
+function time(value, nowMs, fallback) {
+  if (value === void 0) value = fallback;
+  let timestamp;
+  if (typeof value === "number") timestamp = value;
+  else if (typeof value === "string") {
+    const relative = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/.exec(value);
+    if (relative) {
+      const units = {
+        ms: 1,
+        s: 1e3,
+        m: 6e4,
+        h: 36e5,
+        d: 864e5
+      };
+      timestamp = nowMs - Number(relative[1]) * units[relative[2]];
+    } else {
+      return normalizeRunEventQueryTimestamp(value);
+    }
+  } else fail("Run event time bounds require a timestamp or duration.");
+  return normalizeRunEventQueryTimestamp(timestamp);
+}
+function exact(value, name) {
+  if (typeof value !== "string" || !value.trim() || value.length > 256)
+    fail(
+      `Run event ${name} requires a nonempty string of at most 256 characters.`
+    );
+  return value;
+}
+var CRITERIA_KEYS = [
+  "since",
+  "until",
+  "where",
+  "runId",
+  "stepId",
+  "minLevel",
+  "text",
+  "playName",
+  "kind"
+];
+function normalizeRunEventQuery(criteria, nowMs = Date.now()) {
+  if (!object(criteria)) fail("Run event criteria requires an object.");
+  bounded(criteria, RUN_EVENT_QUERY_MAX_REQUEST_BYTES);
+  for (const key of Object.keys(criteria)) {
+    if (!CRITERIA_KEYS.includes(key))
+      fail(`Unsupported run event criterion: ${key}.`);
+  }
+  const until = time(criteria.until, nowMs, nowMs);
+  const since = time(criteria.since, nowMs, Date.parse(until) - 36e5);
+  if (timestampMicros(since) >= timestampMicros(until) || timestampMicros(until) - timestampMicros(since) > BigInt(RUN_EVENT_QUERY_RETENTION_MS) * BigInt(1e3))
+    fail("Run event query requires a window of at most seven days.");
+  const query = { since, until };
+  if (criteria.where !== void 0)
+    query.where = parseRunEventWhere(criteria.where);
+  for (const name of ["runId", "stepId", "playName", "kind"]) {
+    if (criteria[name] !== void 0) query[name] = exact(criteria[name], name);
+  }
+  if (criteria.minLevel !== void 0) {
+    if (!RUN_LOG_LEVELS.includes(criteria.minLevel))
+      fail("Run event minLevel requires debug, info, warn or error.");
+    query.minLevel = criteria.minLevel;
+  }
+  if (criteria.text !== void 0) {
+    if (typeof criteria.text !== "string" || !criteria.text.length || new TextEncoder().encode(criteria.text).length > 1024)
+      fail("Run event text requires between 1 and 1024 bytes.");
+    query.text = criteria.text;
+  }
+  return query;
+}
+function normalizeRunEventOperationRequest(input, nowMs = Date.now()) {
+  bounded(input, RUN_EVENT_QUERY_MAX_REQUEST_BYTES);
+  if (!object(input)) fail("Run event operation requires an object.");
+  const operation = input.operation;
+  if (!["list", "count", "summarize", "fields"].includes(String(operation)))
+    fail("Run event operation requires list, count, summarize or fields.");
+  if (input.resource !== "logs" && input.resource !== "events")
+    fail("Run event resource requires logs or events.");
+  const allowed = [
+    "operation",
+    "resource",
+    "runId",
+    ...operation === "fields" ? [] : CRITERIA_KEYS,
+    ...operation === "list" ? ["limit", "cursor", "includePayloads"] : operation === "summarize" ? ["groupBy", "measures", "limit", "cursor"] : []
+  ];
+  for (const key of Object.keys(input)) {
+    if (!allowed.includes(key))
+      fail(`Run event ${operation} does not support ${key}.`);
+  }
+  const base = {
+    operation,
+    resource: input.resource,
+    ...input.runId === void 0 ? {} : { runId: exact(input.runId, "runId") }
+  };
+  if (operation === "fields") return base;
+  if (input.resource === "logs" && !base.runId)
+    fail("Run event logs require runId.");
+  if (input.cursor !== void 0 && (typeof input.cursor !== "string" || !input.cursor.length || input.cursor.length > RUN_EVENT_QUERY_MAX_CURSOR_BYTES))
+    fail("Run event cursor is invalid.");
+  const rawCriteria = Object.fromEntries(
+    Object.entries(input).filter(
+      ([key]) => CRITERIA_KEYS.includes(key) && (key !== "runId" || input.resource === "events")
+    )
+  );
+  const query = normalizeRunEventQuery(
+    input.cursor === void 0 ? rawCriteria : { ...rawCriteria, since: nowMs - 36e5, until: nowMs },
+    nowMs
+  );
+  const criteria = { ...query };
+  if (input.cursor !== void 0) {
+    if (input.since === void 0) delete criteria.since;
+    else criteria.since = time(input.since, nowMs, nowMs - 36e5);
+    if (input.until === void 0) delete criteria.until;
+    else criteria.until = time(input.until, nowMs, nowMs);
+  }
+  if (operation === "count")
+    return { ...base, ...criteria };
+  const limit = input.limit ?? (input.includePayloads === true ? 10 : 50);
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > RUN_EVENT_QUERY_MAX_LIMIT)
+    fail("Run event limit must be between 1 and 200.");
+  const page = {
+    limit,
+    ...input.cursor === void 0 ? {} : { cursor: input.cursor }
+  };
+  if (operation === "list") {
+    if (input.includePayloads !== void 0 && typeof input.includePayloads !== "boolean")
+      fail("Run event includePayloads requires a boolean.");
+    if (input.includePayloads === true && limit > RUN_EVENT_QUERY_MAX_PAYLOAD_LIMIT)
+      fail("Run event payload pages cannot exceed 10 rows.");
+    return {
+      ...base,
+      ...criteria,
+      ...page,
+      ...input.includePayloads === void 0 ? {} : { includePayloads: input.includePayloads }
+    };
+  }
+  if (!Array.isArray(input.groupBy) || input.groupBy.length > 4)
+    fail("Run event groupBy requires at most four fields.");
+  const groupBy = input.groupBy.map(validateRunEventField);
+  if (new Set(groupBy).size !== groupBy.length)
+    fail("Run event groupBy fields must be distinct.");
+  const rawMeasures = input.measures ?? [{ op: "count" }];
+  if (!Array.isArray(rawMeasures) || rawMeasures.length < 1 || rawMeasures.length > 8)
+    fail("Run event measures require between 1 and 8 entries.");
+  const names = /* @__PURE__ */ new Set();
+  const measures = rawMeasures.map((measure) => {
+    if (!object(measure) || measure.op !== "count" && measure.op !== "sum")
+      fail("Run event measures support count and sum.");
+    for (const key of Object.keys(measure)) {
+      if (!["op", "as", ...measure.op === "sum" ? ["field"] : []].includes(key))
+        fail(`Unsupported run event measure option: ${key}.`);
+    }
+    const field = measure.op === "sum" ? validateRunEventField(measure.field) : void 0;
+    if (field && !field.startsWith("context.") && RUN_EVENT_QUERY_FIELD_CATALOG[field].type !== "number")
+      fail(`Run event sum requires a numeric field: ${field}.`);
+    const name = measure.as ?? (field ? `sum_${field.replaceAll(".", "_")}` : "count");
+    if (typeof name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(name) || names.has(name))
+      fail("Run event measure names must be distinct identifiers.");
+    names.add(name);
+    return field ? { op: "sum", field, as: name } : { op: "count", as: name };
+  });
+  return {
+    ...base,
+    ...criteria,
+    ...page,
+    groupBy,
+    measures
+  };
+}
+
 // src/types.ts
 function isStopAllPlayRunsDryRunResult(result) {
   return "dryRun" in result && result.dryRun === true;
@@ -2555,7 +3078,21 @@ var DeeplineClient = class _DeeplineClient {
       history: (options2) => this.getRunsHistory(options2),
       watch: (runId, options2) => this.watchRunToTerminal(runId, options2),
       tail: (runId, options2) => this.tailRun(runId, options2),
-      logs: (runId, options2) => this.getRunLogs(runId, options2),
+      logs: Object.assign(
+        (runId, options2) => this.getRunLogs(runId, options2),
+        {
+          query: (runId, options2) => this.queryRunLogs(runId, options2),
+          count: (runId, criteria) => this.countRunLogs(runId, criteria),
+          summarize: (runId, options2) => this.summarizeRunLogs(runId, options2),
+          fields: (options2) => this.getRunEventFields("logs", options2)
+        }
+      ),
+      events: {
+        list: (options2) => this.listRunEvents(options2),
+        count: (criteria) => this.countRunEvents(criteria),
+        summarize: (options2) => this.summarizeRunEvents(options2),
+        fields: (options2) => this.getRunEventFields("events", options2)
+      },
       searchEvents: (options2) => this.searchRunEvents(options2),
       input: (runId) => this.getRunInput(runId),
       rerun: (runId, options2) => this.rerun(runId, options2),
@@ -3951,6 +4488,115 @@ var DeeplineClient = class _DeeplineClient {
       ...probe.logsTruncated ? { logsTruncated: true } : {}
     };
   }
+  /** Query one page of this run's retained logs. `where` accepts typed objects or the shared filter language. */
+  async queryRunLogs(runId, options = {}) {
+    this.assertRunLogQueryRunId(runId, options);
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: "list", resource: "logs", runId },
+      runtime
+    );
+  }
+  /** Count matching retained logs exactly, without fetching list pages or saved results. */
+  async countRunLogs(runId, criteria = {}) {
+    this.assertRunLogQueryRunId(runId, criteria);
+    const { runtime, ...query } = criteria;
+    return this.postRunEventQuery(
+      { ...query, operation: "count", resource: "logs", runId },
+      runtime
+    );
+  }
+  /** Summarize retained logs with explicit group pagination and count or numeric sums. */
+  async summarizeRunLogs(runId, options) {
+    this.assertRunLogQueryRunId(runId, options);
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: "summarize", resource: "logs", runId },
+      runtime
+    );
+  }
+  /** Query one page of retained lifecycle, log and receipt events in the active organization. */
+  async listRunEvents(options = {}) {
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: "list", resource: "events" },
+      runtime
+    );
+  }
+  /** Count matching retained events exactly in one server query. */
+  async countRunEvents(criteria = {}) {
+    const { runtime, ...query } = criteria;
+    return this.postRunEventQuery(
+      { ...query, operation: "count", resource: "events" },
+      runtime
+    );
+  }
+  /**
+   * Group retained events with exact counts, numeric sums and continuation.
+   * Fractional sums use JavaScript number precision.
+   */
+  async summarizeRunEvents(options) {
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: "summarize", resource: "events" },
+      runtime
+    );
+  }
+  /** Discover query fields and their recorded types; custom scalar fields use `context.<key>`. */
+  async getRunEventFields(resource = "events", options = {}) {
+    const { runtime, ...query } = options;
+    return this.postRunEventQuery(
+      { ...query, operation: "fields", resource },
+      runtime
+    );
+  }
+  async postRunEventQuery(input, selection) {
+    const request = normalizeRunEventOperationRequest(input);
+    const params = new URLSearchParams();
+    let headers;
+    let selectedRuntime;
+    if (selection !== void 0) {
+      const runtime = normalizePlayRuntimeSelection(selection);
+      if (!runtime) {
+        throw new DeeplineError(
+          "Run event queries require a valid Preview runtime selection.",
+          void 0,
+          "INVALID_RUNTIME_SELECTION"
+        );
+      }
+      params.set("runtime", "preview");
+      params.set("namespace", runtime.namespace);
+      if (runtime.backend) params.set("backend", runtime.backend);
+      headers = runtimeSelectionHeaders(runtime);
+      selectedRuntime = runtime;
+    } else {
+      headers = isolatedCiRuntimeEventReadHeaders();
+    }
+    const suffix = params.size > 0 ? `?${params.toString()}` : "";
+    const result = await this.http.post(
+      `/api/v2/runs/events${suffix}`,
+      request,
+      headers,
+      { retryApiErrors: true }
+    );
+    if (selectedRuntime && result && typeof result === "object" && "query" in result) {
+      return {
+        ...result,
+        query: {
+          ...result.query,
+          runtime: selectedRuntime
+        }
+      };
+    }
+    return result;
+  }
+  assertRunLogQueryRunId(runId, criteria) {
+    if (criteria && typeof criteria === "object" && "runId" in criteria && criteria.runId !== void 0 && criteria.runId !== runId) {
+      throw new RunEventQueryInputError(
+        "Log criteria runId conflicts with the positional run ID. Pass the run ID only as the first argument."
+      );
+    }
+  }
   /** Read structured history across the active organization without requiring a run ID. Defaults to the last hour, newest first; use the returned cursor and exact time bounds to continue. See [run logs and events](run-events.md) for all kinds, indexed fields, payloads and SDK/API response types. */
   async searchRunEvents(options = {}) {
     const now = Date.now();
@@ -5724,6 +6370,8 @@ export {
   isTransientPlayRunReadError,
   encodeRunLogsCursor,
   isRunLogsCursor,
+  RunEventQueryInputError,
+  normalizeRunEventOperationRequest,
   isStopAllPlayRunsDryRunResult,
   MONITOR_JOB_STATES,
   MONITOR_JOB_PHASES,