@deepagents/text2sql 7.0.1 → 7.1.0

package/dist/lib/adapters/posthog/index.js

@@ -1,191 +1,6 @@
-// packages/text2sql/src/lib/adapters/groundings/abstract.grounding.ts
-function filterColumns(columns, filter) {
-  if (Array.isArray(filter)) {
-    return columns.filter((col) => filter.includes(col.name));
-  }
-  if (filter instanceof RegExp) {
-    return columns.filter((col) => filter.test(col.name));
-  }
-  return columns.filter((col) => filter(col.name));
-}
-function applyColumnFilter(entity, columnsConfig) {
-  if (!columnsConfig) return entity;
-  const filter = columnsConfig[entity.name];
-  if (!filter) return entity;
-  return { ...entity, columns: filterColumns(entity.columns, filter) };
-}
-var AbstractGrounding = class {
-  /**
-   * Grounding identifier for debugging/logging.
-   */
-  name;
-  phase;
-  constructor(name, phase) {
-    this.name = name;
-    this.phase = phase;
-  }
-  /**
-   * Populate ctx with the tables/views this grounding makes available for scope
-   * resolution. Annotators decorate entities other groundings produced and add
-   * no membership, so the default is a no-op; entity-producing groundings
-   * override it. This lets scope resolution skip the annotators' metadata scans.
-   *
-   * @param _ctx - Shared context for accumulating entity membership
-   */
-  async contributeEntities(_ctx) {
-  }
-};
-
-// packages/text2sql/src/lib/adapters/posthog/definitions.posthog.grounding.ts
-var PostHogDefinitionsGrounding = class extends AbstractGrounding {
-  #adapter;
-  #config;
-  constructor(adapter, config = {}) {
-    super("definitions", "definitions");
-    this.#adapter = adapter;
-    this.#config = config;
-  }
-  async execute(ctx) {
-    const fragments = ctx.fragments ??= [];
-    const configuredPropertyTypes = this.#config.propertyTypes ?? ["event", "person", "session"];
-    const propertyTypes = [
-      ...new Set(configuredPropertyTypes)
-    ];
-    validatePropertyTypes(propertyTypes);
-    const groupTypeIndexes = [...new Set(this.#config.groupTypeIndexes ?? [])];
-    if (groupTypeIndexes.some((index2) => !Number.isInteger(index2) || index2 < 0)) {
-      throw new Error(
-        "PostHog groupTypeIndexes must contain non-negative integers."
-      );
-    }
-    const propertyRequests = [
-      ...propertyTypes.map(async (type) => ({
-        type,
-        definitions: await this.#adapter.transport.listPropertyDefinitions({
-          type
-        })
-      })),
-      ...groupTypeIndexes.map(async (groupTypeIndex) => ({
-        type: `group:${groupTypeIndex}`,
-        definitions: await this.#adapter.transport.listPropertyDefinitions({
-          type: "group",
-          groupTypeIndex
-        })
-      }))
-    ];
-    const [events, properties] = await Promise.all([
-      this.#adapter.transport.listEventDefinitions(),
-      Promise.all(propertyRequests)
-    ]);
-    const eventData = readEvents(events, this.#config.events);
-    if (eventData.length > 0) {
-      fragments.push({ name: "posthogEvents", data: eventData });
-    }
-    const propertyData = {};
-    for (const group of properties) {
-      const definitions2 = readProperties(
-        group.definitions,
-        this.#config.properties
-      );
-      if (definitions2.length > 0) propertyData[group.type] = definitions2;
-    }
-    if (Object.keys(propertyData).length > 0) {
-      fragments.push({
-        name: "posthogProperties",
-        data: propertyData
-      });
-    }
-  }
-};
-function readEvents(values, filter) {
-  return values.map(validateEvent).filter((event) => matchesFilter(event.name, filter)).toSorted((left, right) => left.name.localeCompare(right.name)).map(
-    (event) => compact({
-      name: event.name,
-      description: event.description ?? void 0,
-      tags: event.tags?.length ? event.tags : void 0,
-      verified: event.verified ?? void 0
-    })
-  );
-}
-function readProperties(values, filter) {
-  return values.map(validateProperty).filter((property) => matchesFilter(property.name, filter)).toSorted((left, right) => left.name.localeCompare(right.name)).map(
-    (property) => compact({
-      name: property.name,
-      description: property.description ?? void 0,
-      propertyType: property.property_type ?? void 0,
-      numerical: property.is_numerical ?? void 0,
-      verified: property.verified ?? void 0
-    })
-  );
-}
-function validateEvent(value) {
-  if (!isRecord(value) || !readNonEmptyString(value.name) || !isOptionalString(value.description) || !isOptionalBoolean(value.verified) || !isOptionalStringArray(value.tags)) {
-    throw new Error("PostHog returned a malformed event definition.");
-  }
-  return value;
-}
-function validateProperty(value) {
-  if (!isRecord(value) || !readNonEmptyString(value.name) || !isOptionalString(value.description) || !isOptionalString(value.property_type) || !isOptionalBoolean(value.is_numerical) || !isOptionalBoolean(value.verified)) {
-    throw new Error("PostHog returned a malformed property definition.");
-  }
-  return value;
-}
-function validatePropertyTypes(values) {
-  const allowed = /* @__PURE__ */ new Set(["event", "person", "session"]);
-  if (values.some((value) => !allowed.has(value))) {
-    throw new Error("PostHog propertyTypes contains an unsupported type.");
-  }
-}
-function matchesFilter(name, filter) {
-  if (!filter) return true;
-  if (Array.isArray(filter)) return filter.includes(name);
-  if (filter instanceof RegExp) {
-    filter.lastIndex = 0;
-    return filter.test(name);
-  }
-  return filter(name);
-}
-function compact(value) {
-  return Object.fromEntries(
-    Object.entries(value).filter((entry) => entry[1] !== void 0)
-  );
-}
-function isOptionalString(value) {
-  return value === void 0 || value === null || typeof value === "string";
-}
-function isOptionalBoolean(value) {
-  return value === void 0 || value === null || typeof value === "boolean";
-}
-function isOptionalStringArray(value) {
-  return value === void 0 || value === null || Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function readNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// packages/text2sql/src/lib/adapters/posthog/info.posthog.grounding.ts
-var PostHogInfoGrounding = class extends AbstractGrounding {
-  constructor() {
-    super("info", "info");
-  }
-  async execute(ctx) {
-    ctx.info = {
-      dialect: "HogQL",
-      details: {
-        identifierQuoting: "Use backticks for identifiers that require quoting.",
-        propertyAccess: "Use PostHog HogQL property access and the grounded event/person/session property definitions. Do not guess property names.",
-        performance: "Prefer bounded time ranges and LIMIT for non-aggregate event queries. OFFSET is not supported by the Query API.",
-        execution: "Queries run through PostHog as read-only HogQLQuery nodes, not through a PostgreSQL connection."
-      }
-    };
-  }
-};
-
 // packages/text2sql/src/lib/adapters/adapter.ts
 import { format as formatSql } from "sql-formatter";
+import { z } from "zod";
 
 // packages/text2sql/src/lib/agents/exceptions.ts
 var sqlValidationMarker = /* @__PURE__ */ Symbol("SQLValidationError");
@@ -358,6 +173,16 @@ function createGroundingContext(options = {}) {
 }
 
 // packages/text2sql/src/lib/adapters/adapter.ts
+function groundingFor(adapterType, create) {
+  return (adapter) => {
+    if (!(adapter instanceof adapterType)) {
+      throw new Error(
+        `A ${adapterType.name} grounding needs a ${adapterType.name} adapter, not ${adapter.constructor.name}.`
+      );
+    }
+    return create(adapter);
+  };
+}
 var Adapter = class {
   #policyAnalyzer;
   /**
@@ -618,6 +443,40 @@ var Adapter = class {
     }
     return decoded;
   }
+  /**
+   * Run an introspection query and check every row against `row`, the shape
+   * the driver returns for that query. A row of any other shape throws.
+   */
+  async runQuery(sql, row) {
+    const rows = z.array(row).safeParse(await this.queryRows(sql));
+    if (!rows.success) {
+      throw new Error(
+        `${this.constructor.name} introspection query returned rows of an unexpected shape:
+${z.prettifyError(rows.error)}
+SQL: ${sql.trim()}`,
+        { cause: rows.error }
+      );
+    }
+    return rows.data;
+  }
+  /**
+   * The rows in a driver's execute() result: the result itself when it is an
+   * array, otherwise the first array found at one of `paths` (dot-separated,
+   * so `recordsets.0` reads `result.recordsets[0]`).
+   */
+  rowsFrom(result, paths) {
+    if (Array.isArray(result)) return result;
+    for (const path of paths) {
+      const rows = path.split(".").reduce(
+        (value, key) => typeof value === "object" && value !== null ? Reflect.get(value, key) : void 0,
+        result
+      );
+      if (Array.isArray(rows)) return rows;
+    }
+    throw new Error(
+      `${this.constructor.name} execute() must return an array of rows or an object holding one at ${paths.map((path) => `result.${path}`).join(", ")}.`
+    );
+  }
   /**
    * Convert unknown database value to number.
    * Handles number, bigint, and string types.
@@ -670,6 +529,203 @@ var Adapter = class {
   }
 };
 
+// packages/text2sql/src/lib/adapters/posthog/definitions.posthog.grounding.ts
+import { z as z2 } from "zod";
+
+// packages/text2sql/src/lib/adapters/groundings/abstract.grounding.ts
+function filterColumns(columns, filter) {
+  if (Array.isArray(filter)) {
+    return columns.filter((col) => filter.includes(col.name));
+  }
+  if (filter instanceof RegExp) {
+    return columns.filter((col) => filter.test(col.name));
+  }
+  return columns.filter((col) => filter(col.name));
+}
+function applyColumnFilter(entity, columnsConfig) {
+  if (!columnsConfig) return entity;
+  const filter = columnsConfig[entity.name];
+  if (!filter) return entity;
+  return { ...entity, columns: filterColumns(entity.columns, filter) };
+}
+var AbstractGrounding = class {
+  /**
+   * Grounding identifier for debugging/logging.
+   */
+  name;
+  phase;
+  constructor(name, phase) {
+    this.name = name;
+    this.phase = phase;
+  }
+  /**
+   * Populate ctx with the tables/views this grounding makes available for scope
+   * resolution. Annotators decorate entities other groundings produced and add
+   * no membership, so the default is a no-op; entity-producing groundings
+   * override it. This lets scope resolution skip the annotators' metadata scans.
+   *
+   * @param _ctx - Shared context for accumulating entity membership
+   */
+  async contributeEntities(_ctx) {
+  }
+};
+
+// packages/text2sql/src/lib/adapters/posthog/definitions.posthog.grounding.ts
+var postHogEventDefinition = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().nullish(),
+  tags: z2.array(z2.string()).nullish(),
+  verified: z2.boolean().nullish()
+});
+var postHogPropertyDefinition = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().nullish(),
+  property_type: z2.string().nullish(),
+  is_numerical: z2.boolean().nullish(),
+  verified: z2.boolean().nullish()
+});
+var PostHogDefinitionsGrounding = class extends AbstractGrounding {
+  #adapter;
+  #config;
+  constructor(adapter, config = {}) {
+    super("definitions", "definitions");
+    this.#adapter = adapter;
+    this.#config = config;
+  }
+  async execute(ctx) {
+    const fragments = ctx.fragments ??= [];
+    const configuredPropertyTypes = this.#config.propertyTypes ?? ["event", "person", "session"];
+    const propertyTypes = [
+      ...new Set(configuredPropertyTypes)
+    ];
+    validatePropertyTypes(propertyTypes);
+    const groupTypeIndexes = [...new Set(this.#config.groupTypeIndexes ?? [])];
+    if (groupTypeIndexes.some((index2) => !Number.isInteger(index2) || index2 < 0)) {
+      throw new Error(
+        "PostHog groupTypeIndexes must contain non-negative integers."
+      );
+    }
+    const propertyRequests = [
+      ...propertyTypes.map(async (type) => ({
+        type,
+        definitions: await this.#adapter.transport.listPropertyDefinitions({
+          type
+        })
+      })),
+      ...groupTypeIndexes.map(async (groupTypeIndex) => ({
+        type: `group:${groupTypeIndex}`,
+        definitions: await this.#adapter.transport.listPropertyDefinitions({
+          type: "group",
+          groupTypeIndex
+        })
+      }))
+    ];
+    const [events, properties] = await Promise.all([
+      this.#adapter.transport.listEventDefinitions(),
+      Promise.all(propertyRequests)
+    ]);
+    const eventData = readEvents(events, this.#config.events);
+    if (eventData.length > 0) {
+      fragments.push({ name: "posthogEvents", data: eventData });
+    }
+    const propertyData = {};
+    for (const group of properties) {
+      const definitions2 = readProperties(
+        group.definitions,
+        this.#config.properties
+      );
+      if (definitions2.length > 0) propertyData[group.type] = definitions2;
+    }
+    if (Object.keys(propertyData).length > 0) {
+      fragments.push({
+        name: "posthogProperties",
+        data: propertyData
+      });
+    }
+  }
+};
+function readEvents(values, filter) {
+  return values.map(validateEvent).filter((event) => matchesFilter(event.name, filter)).toSorted((left, right) => left.name.localeCompare(right.name)).map(
+    (event) => compact({
+      name: event.name,
+      description: event.description ?? void 0,
+      tags: event.tags?.length ? event.tags : void 0,
+      verified: event.verified ?? void 0
+    })
+  );
+}
+function readProperties(values, filter) {
+  return values.map(validateProperty).filter((property) => matchesFilter(property.name, filter)).toSorted((left, right) => left.name.localeCompare(right.name)).map(
+    (property) => compact({
+      name: property.name,
+      description: property.description ?? void 0,
+      propertyType: property.property_type ?? void 0,
+      numerical: property.is_numerical ?? void 0,
+      verified: property.verified ?? void 0
+    })
+  );
+}
+function validateEvent(value) {
+  const event = postHogEventDefinition.safeParse(value);
+  if (!event.success) {
+    throw new Error("PostHog returned a malformed event definition.");
+  }
+  return event.data;
+}
+function validateProperty(value) {
+  const property = postHogPropertyDefinition.safeParse(value);
+  if (!property.success) {
+    throw new Error("PostHog returned a malformed property definition.");
+  }
+  return property.data;
+}
+function validatePropertyTypes(values) {
+  const allowed = /* @__PURE__ */ new Set(["event", "person", "session"]);
+  if (values.some((value) => !allowed.has(value))) {
+    throw new Error("PostHog propertyTypes contains an unsupported type.");
+  }
+}
+function matchesFilter(name, filter) {
+  if (!filter) return true;
+  if (Array.isArray(filter)) return filter.includes(name);
+  if (filter instanceof RegExp) {
+    filter.lastIndex = 0;
+    return filter.test(name);
+  }
+  return filter(name);
+}
+function compact(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      (entry) => entry[1] !== void 0
+    )
+  );
+}
+
+// packages/text2sql/src/lib/adapters/posthog/info.posthog.grounding.ts
+var PostHogInfoGrounding = class extends AbstractGrounding {
+  constructor() {
+    super("info", "info");
+  }
+  async execute(ctx) {
+    ctx.info = {
+      dialect: "HogQL",
+      details: {
+        identifierQuoting: "Use backticks for identifiers that require quoting.",
+        propertyAccess: "Use PostHog HogQL property access and the grounded event/person/session property definitions. Do not guess property names.",
+        performance: "Prefer bounded time ranges and LIMIT for non-aggregate event queries. OFFSET is not supported by the Query API.",
+        execution: "Queries run through PostHog as read-only HogQLQuery nodes, not through a PostgreSQL connection."
+      }
+    };
+  }
+};
+
+// packages/text2sql/src/lib/adapters/posthog/posthog.ts
+import { z as z4 } from "zod";
+
+// packages/text2sql/src/lib/adapters/posthog/posthog.sql-policy.ts
+import { z as z3 } from "zod";
+
 // packages/text2sql/src/lib/sql-scope-error.ts
 function buildScopeParseErrorPayload(sql, parserDialect, error) {
   const parserError = error instanceof Error ? error.message : String(error ?? "Unknown error");
@@ -684,6 +740,12 @@ function buildScopeParseErrorPayload(sql, parserDialect, error) {
 }
 
 // packages/text2sql/src/lib/adapters/posthog/posthog.sql-policy.ts
+var postHogNotice = z3.object({
+  start: z3.number().nullish(),
+  end: z3.number().nullish(),
+  message: z3.string(),
+  fix: z3.string().nullish()
+});
 var PostHogSqlPolicyAnalyzer = class {
   #transport;
   constructor(transport) {
@@ -715,15 +777,15 @@ var PostHogSqlPolicyAnalyzer = class {
   }
 };
 function validateMetadataResponse(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord(value)) {
     throw new Error("PostHog HogQLMetadata response must be a JSON object.");
   }
   if (typeof value.isValid !== "boolean") {
     throw new Error("PostHog HogQLMetadata response has no isValid boolean.");
   }
   const errors = validateNotices(value.errors, "errors");
-  validateNotices(value.warnings, "warnings");
-  validateNotices(value.notices, "notices");
+  const warnings = validateNotices(value.warnings, "warnings");
+  const notices = validateNotices(value.notices, "notices");
   const tableNames = validateTableNames(value.table_names);
   if (!value.isValid || errors.length > 0) {
     const reason = errors.map((notice) => notice.message).join("; ");
@@ -734,8 +796,8 @@ function validateMetadataResponse(value) {
   return {
     isValid: true,
     errors,
-    warnings: value.warnings,
-    notices: value.notices,
+    warnings,
+    notices,
     table_names: tableNames
   };
 }
@@ -743,14 +805,13 @@ function validateNotices(value, name) {
   if (!Array.isArray(value)) {
     throw new Error(`PostHog HogQLMetadata response has no ${name} array.`);
   }
-  for (const notice of value) {
-    if (!isRecord2(notice) || typeof notice.message !== "string") {
-      throw new Error(
-        `PostHog HogQLMetadata response has an invalid ${name} notice.`
-      );
-    }
+  const notices = z3.array(postHogNotice).safeParse(value);
+  if (!notices.success) {
+    throw new Error(
+      `PostHog HogQLMetadata response has an invalid ${name} notice.`
+    );
   }
-  return value;
+  return notices.data;
 }
 function validateTableNames(value) {
   if (!Array.isArray(value) || value.some((name) => typeof name !== "string" || name.length === 0)) {
@@ -771,11 +832,15 @@ function buildOutOfScopePayload(sql, referencedEntities, allowedEntities) {
 function caseFold(value) {
   return value.toLowerCase();
 }
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // packages/text2sql/src/lib/adapters/posthog/posthog.ts
+var hogQLQueryResponse = z4.object({
+  results: z4.array(z4.array(z4.unknown())),
+  columns: z4.array(z4.string().min(1)).optional()
+});
 var PostHog = class extends Adapter {
   transport;
   grounding;
@@ -808,8 +873,8 @@ var PostHog = class extends Adapter {
   validateImpl() {
     return void 0;
   }
-  async runQuery(sql) {
-    return await this.#execute(sql, "deepagents_text2sql_grounding");
+  queryRows(sql) {
+    return this.#execute(sql, "deepagents_text2sql_grounding");
   }
   quoteIdentifier(name) {
     return `\`${name.replace(/`/g, "``")}\``;
@@ -839,28 +904,27 @@ var PostHog = class extends Adapter {
   }
 };
 function rowsFromResponse(value) {
-  if (!isRecord3(value) || !Array.isArray(value.results)) {
-    throw new Error("PostHog HogQLQuery response has no results array.");
-  }
-  if (value.columns !== void 0 && (!Array.isArray(value.columns) || value.columns.some(
-    (column2) => typeof column2 !== "string" || column2.length === 0
-  ))) {
-    throw new Error("PostHog HogQLQuery response has invalid columns.");
+  const response = hogQLQueryResponse.safeParse(value);
+  if (!response.success) {
+    throw new Error(
+      `PostHog HogQLQuery response is malformed:
+${z4.prettifyError(response.error)}`
+    );
   }
-  if (Array.isArray(value.columns) && new Set(value.columns).size !== value.columns.length) {
+  const { columns, results } = response.data;
+  if (columns && new Set(columns).size !== columns.length) {
     throw new Error(
       "PostHog HogQLQuery response contains duplicate column names; alias every selected expression uniquely."
     );
   }
-  if (value.results.length === 0) return [];
-  if (!Array.isArray(value.columns)) {
+  if (results.length === 0) return [];
+  if (!columns) {
     throw new Error(
       "PostHog HogQLQuery response requires columns for non-empty results."
     );
   }
-  const columns = value.columns;
-  return value.results.map((row, index2) => {
-    if (!Array.isArray(row) || row.length !== columns.length) {
+  return results.map((row, index2) => {
+    if (row.length !== columns.length) {
       throw new Error(
         `PostHog HogQLQuery result row ${index2} does not match the column count.`
       );
@@ -870,12 +934,10 @@ function rowsFromResponse(value) {
     );
   });
 }
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // packages/text2sql/src/lib/adapters/posthog/schema.posthog.grounding.ts
-var SCALAR_FIELD_TYPES = /* @__PURE__ */ new Set([
+import { z as z5 } from "zod";
+var scalarFieldType = z5.enum([
   "integer",
   "float",
   "decimal",
@@ -886,32 +948,59 @@ var SCALAR_FIELD_TYPES = /* @__PURE__ */ new Set([
   "array",
   "json"
 ]);
-var FIELD_TYPES = /* @__PURE__ */ new Set([
-  ...SCALAR_FIELD_TYPES,
-  "lazy_table",
-  "virtual_table",
-  "field_traverser",
-  "expression",
-  "view",
-  "materialized_view",
-  "unknown"
-]);
-var TABLE_TYPES = /* @__PURE__ */ new Set([
-  "posthog",
-  "system",
-  "data_warehouse",
+var SCALAR_FIELD_TYPES = new Set(
+  scalarFieldType.options
+);
+var viewTableType = z5.enum([
   "view",
-  "batch_export",
   "materialized_view",
   "managed_view",
   "endpoint"
 ]);
-var VIEW_TYPES = /* @__PURE__ */ new Set([
-  "view",
-  "materialized_view",
-  "managed_view",
-  "endpoint"
+var VIEW_TYPES = new Set(viewTableType.options);
+var postHogDatabaseField = z5.object({
+  name: z5.string(),
+  hogql_value: z5.string(),
+  type: z5.enum([
+    ...scalarFieldType.options,
+    "lazy_table",
+    "virtual_table",
+    "field_traverser",
+    "expression",
+    "view",
+    "materialized_view",
+    "unknown"
+  ]),
+  schema_valid: z5.boolean()
+});
+var tableMembers = {
+  id: z5.string(),
+  name: z5.string(),
+  fields: z5.record(z5.string(), postHogDatabaseField),
+  row_count: z5.number().nonnegative().nullish()
+};
+var postHogDatabaseTable = z5.discriminatedUnion("type", [
+  z5.object({
+    ...tableMembers,
+    type: z5.enum(["posthog", "system", "data_warehouse", "batch_export"])
+  }),
+  z5.object({
+    ...tableMembers,
+    type: viewTableType,
+    query: z5.object({ query: z5.string() })
+  })
 ]);
+var postHogSchemaJoin = z5.object({
+  source_table_name: z5.string().nullish(),
+  source_table_key: z5.string().nullish(),
+  joining_table_name: z5.string().nullish(),
+  joining_table_key: z5.string().nullish(),
+  field_name: z5.string().nullish()
+});
+var postHogSchemaResponse = z5.object({
+  tables: z5.record(z5.string(), postHogDatabaseTable),
+  joins: z5.array(postHogSchemaJoin)
+});
 var PostHogSchemaGrounding = class extends AbstractGrounding {
   #adapter;
   #config;
@@ -975,44 +1064,14 @@ var PostHogSchemaGrounding = class extends AbstractGrounding {
   }
 };
 function validateSchemaResponse(value) {
-  if (!isRecord4(value) || !isRecord4(value.tables) || !Array.isArray(value.joins)) {
+  const response = postHogSchemaResponse.safeParse(value);
+  if (!response.success) {
     throw new Error(
-      "PostHog DatabaseSchemaQuery response must contain tables and joins."
+      `PostHog DatabaseSchemaQuery response is malformed:
+${z5.prettifyError(response.error)}`
     );
   }
-  for (const [name, valueTable] of Object.entries(value.tables)) {
-    if (!isRecord4(valueTable)) {
-      throw new Error(`PostHog schema table ${name} must be an object.`);
-    }
-    if (!TABLE_TYPES.has(valueTable.type)) {
-      throw new Error(`PostHog schema table ${name} has an unknown type.`);
-    }
-    if (typeof valueTable.id !== "string" || typeof valueTable.name !== "string" || !isRecord4(valueTable.fields)) {
-      throw new Error(`PostHog schema table ${name} is malformed.`);
-    }
-    if (valueTable.row_count !== void 0 && valueTable.row_count !== null && (typeof valueTable.row_count !== "number" || !Number.isFinite(valueTable.row_count) || valueTable.row_count < 0)) {
-      throw new Error(`PostHog schema table ${name} has an invalid row_count.`);
-    }
-    if (VIEW_TYPES.has(valueTable.type) && (!isRecord4(valueTable.query) || typeof valueTable.query.query !== "string")) {
-      throw new Error(`PostHog schema view ${name} has an invalid query.`);
-    }
-    validateFields(name, valueTable.fields);
-  }
-  for (const join of value.joins) {
-    if (!isRecord4(join)) {
-      throw new Error("PostHog schema contains a malformed join.");
-    }
-  }
-  return value;
-}
-function validateFields(tableName, fields) {
-  for (const [name, value] of Object.entries(fields)) {
-    if (!isRecord4(value) || typeof value.name !== "string" || typeof value.hogql_value !== "string" || typeof value.schema_valid !== "boolean" || !FIELD_TYPES.has(value.type)) {
-      throw new Error(
-        `PostHog schema field ${tableName}.${name} is malformed or has an unknown type.`
-      );
-    }
-  }
+  return response.data;
 }
 function readColumns(tableName, table2) {
   const columns = [];
@@ -1041,10 +1100,10 @@ function readRelationships(joins, tables, views) {
     ])
   );
   return joins.flatMap((join) => {
-    const sourceTable = readNonEmptyString2(join.source_table_name);
-    const sourceKey = readNonEmptyString2(join.source_table_key);
-    const joiningTable = readNonEmptyString2(join.joining_table_name);
-    const joiningKey = readNonEmptyString2(join.joining_table_key);
+    const sourceTable = readNonEmptyString(join.source_table_name);
+    const sourceKey = readNonEmptyString(join.source_table_key);
+    const joiningTable = readNonEmptyString(join.joining_table_name);
+    const joiningKey = readNonEmptyString(join.joining_table_key);
     if (!sourceTable || !sourceKey || !joiningTable || !joiningKey || !entityColumns.get(sourceTable)?.has(sourceKey) || !entityColumns.get(joiningTable)?.has(joiningKey)) {
       return [];
     }
@@ -1067,12 +1126,9 @@ function matchesFilter2(name, filter) {
   }
   return filter(name);
 }
-function readNonEmptyString2(value) {
+function readNonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // packages/text2sql/src/lib/adapters/posthog/transport.ts
 var DEFAULT_TIMEOUT_MS = 45e3;
@@ -1180,7 +1236,7 @@ function createPostHogTransport(options) {
   };
   return {
     async query(request) {
-      return await requestJson(`${projectPath}/query/`, {
+      return requestJson(`${projectPath}/query/`, {
         method: "POST",
         body: JSON.stringify(request)
       });
@@ -1248,7 +1304,7 @@ function parseJson(body) {
   }
 }
 function apiError(response, body, accessToken) {
-  const record = isRecord5(body) ? body : void 0;
+  const record = isRecord2(body) ? body : void 0;
   const detail = redact(
     readString(record?.detail) ?? readString(record?.error),
     accessToken
@@ -1273,10 +1329,10 @@ function parseRetryAfter(value) {
   return Number.isFinite(date) ? Math.max(0, date - Date.now()) : void 0;
 }
 function asRecord(value, label) {
-  if (!isRecord5(value)) throw new Error(`${label} must be a JSON object.`);
+  if (!isRecord2(value)) throw new Error(`${label} must be a JSON object.`);
   return value;
 }
-function isRecord5(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString(value) {
@@ -1291,10 +1347,16 @@ function info() {
   return () => new PostHogInfoGrounding();
 }
 function schema(config = {}) {
-  return (adapter) => new PostHogSchemaGrounding(adapter, config);
+  return groundingFor(
+    PostHog,
+    (adapter) => new PostHogSchemaGrounding(adapter, config)
+  );
 }
 function definitions(config = {}) {
-  return (adapter) => new PostHogDefinitionsGrounding(adapter, config);
+  return groundingFor(
+    PostHog,
+    (adapter) => new PostHogDefinitionsGrounding(adapter, config)
+  );
 }
 var posthog_default = {
   PostHog,