@sixb/pg 0.1.3 → 0.1.5

package/dist/agents/checkpoints.d.ts

@@ -8,5 +8,9 @@ export declare class PgAgentContextCheckpointStore implements AgentContextCheckp
         readonly projectId: string;
         readonly threadId: string;
     }): Promise<AgentContextCheckpointRecord | null>;
+    getByRunIds(input: {
+        readonly projectId: string;
+        readonly runIds: readonly string[];
+    }): Promise<readonly AgentContextCheckpointRecord[]>;
 }
 //# sourceMappingURL=checkpoints.d.ts.map

package/dist/agents/checkpoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpoints.d.ts","sourceRoot":"","sources":["../../src/agents/checkpoints.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAEhC,KAAK,iCAAiC,EACvC,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,KAAK,aAAa,EAAoB,MAAM,iBAAiB,CAAA;AAYtE,qBAAa,6BAA8B,YAAW,2BAA2B;IACnE,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,aAAa;IAEzC,MAAM,CAAC,KAAK,EAAE,iCAAiC,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAqIvF,SAAS,CAAC,KAAK,EAAE;QACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;QAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAC1B,GAAG,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC;CASjD"}
+{"version":3,"file":"checkpoints.d.ts","sourceRoot":"","sources":["../../src/agents/checkpoints.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAEhC,KAAK,iCAAiC,EACvC,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,KAAK,aAAa,EAAoB,MAAM,iBAAiB,CAAA;AActE,qBAAa,6BAA8B,YAAW,2BAA2B;IACnE,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,aAAa;IAEzC,MAAM,CAAC,KAAK,EAAE,iCAAiC,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAqIvF,SAAS,CAAC,KAAK,EAAE;QACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;QAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAC1B,GAAG,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC;IAU1C,WAAW,CAAC,KAAK,EAAE;QACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;QAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;KACnC,GAAG,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAAC;CAuBrD"}

package/dist/index.js

@@ -213,6 +213,8 @@ async function queryAgentList(input) {
 }
 
 // src/agents/checkpoints.ts
+var PG_CHECKPOINT_RUN_ID_BATCH_SIZE = 1e4;
+
 class PgAgentContextCheckpointStore {
   sql;
   constructor(sql) {
@@ -343,6 +345,22 @@ class PgAgentContextCheckpointStore {
     `;
     return row ? rowToContextCheckpointRecord(row) : null;
   }
+  async getByRunIds(input) {
+    const runIds = [...new Set(input.runIds)];
+    if (runIds.length === 0)
+      return [];
+    const rows = [];
+    for (let offset = 0;offset < runIds.length; offset += PG_CHECKPOINT_RUN_ID_BATCH_SIZE) {
+      const batch = runIds.slice(offset, offset + PG_CHECKPOINT_RUN_ID_BATCH_SIZE);
+      const placeholders = batch.map((_, index) => `$${index + 2}`).join(", ");
+      rows.push(...await this.sql.unsafe(`SELECT * FROM agent_context_checkpoints WHERE project_id = $1 AND created_by_run_id IN (${placeholders})`, [input.projectId, ...batch]));
+    }
+    const byRunId = new Map(rows.map((row) => [row.created_by_run_id, rowToContextCheckpointRecord(row)]));
+    return runIds.flatMap((runId) => {
+      const checkpoint = byRunId.get(runId);
+      return checkpoint ? [checkpoint] : [];
+    });
+  }
 }
 
 // src/agents/messages.ts
@@ -10718,6 +10736,17 @@ class PgAiUsageStorage {
     });
     return summary;
   }
+  async getLatestForExecution(input) {
+    assertNonBlankProjectId(input.projectId);
+    assertAiUsageExecutionId(input.executionId);
+    const [row] = await this.sql`
+      SELECT * FROM ai_model_call_usage
+      WHERE project_id = ${input.projectId} AND execution_id = ${input.executionId}
+      ORDER BY occurred_at DESC, id DESC
+      LIMIT 1
+    `;
+    return row ? this.rowToRecord(this.sql, row) : null;
+  }
   async summarizeExecutions(input) {
     assertNonBlankProjectId(input.projectId);
     for (const executionId of input.executionIds)
@@ -10980,6 +11009,9 @@ function toStorageRow(row) {
   };
 }
 
+// src/pg-object-storage.ts
+import { linkBatchKey, objectBatchKey } from "@sixb/core/storage";
+
 // src/pg-object-query-compiler.ts
 import {
   ObjectQueryExecutionError
@@ -11045,6 +11077,8 @@ function compileObjectQueryInternal(projectId, query, ctx) {
   switch (query.kind) {
     case "start":
       return compileStart(projectId, query);
+    case "refs":
+      return compileRefs(projectId, query);
     case "filter":
       return compileFilter(projectId, query.input, query.predicate);
     case "sort":
@@ -11091,6 +11125,50 @@ function compileStart(projectId, query) {
     }
   };
 }
+function compileRefs(projectId, query) {
+  if (query.refs.length === 0) {
+    throw new Error("[SixbPg] PostgreSQL object storage requires at least one ref");
+  }
+  const order = compileOrder(identityOrderFields());
+  const selectedOrder = compileOrder(identityOrderFields(), "selected");
+  const refsJson = JSON.stringify(query.refs);
+  const requested = `
+    SELECT DISTINCT
+      ref.value ->> 'objectTypeId' AS object_type_id,
+      ref.value ->> 'primaryId' AS primary_id
+    FROM jsonb_array_elements(?::text::jsonb) AS ref(value)
+  `;
+  const sql = `
+    WITH requested AS (${requested})
+    SELECT selected.*, selected.properties AS _cursor_properties
+    FROM requested
+    JOIN objects AS selected
+      ON selected.project_id = ?
+     AND selected.object_type_id = requested.object_type_id
+     AND selected.primary_id = requested.primary_id
+    ORDER BY ${selectedOrder.sql}
+  `;
+  return {
+    sql,
+    args: [refsJson, projectId, ...selectedOrder.args],
+    totalSql: `
+      WITH requested AS (${requested})
+      SELECT COUNT(*)::bigint AS total
+      FROM requested
+      JOIN objects AS selected
+        ON selected.project_id = ?
+       AND selected.object_type_id = requested.object_type_id
+       AND selected.primary_id = requested.primary_id
+    `,
+    totalArgs: [refsJson, projectId],
+    order,
+    hasMore: () => false,
+    trimRows: identityRows,
+    nextPageToken: () => {
+      return;
+    }
+  };
+}
 function compileFilter(projectId, inputQuery, predicateNode) {
   return compileWhere(projectId, inputQuery, compilePredicate(predicateNode));
 }
@@ -11455,6 +11533,8 @@ function compileAggregateSource(projectId, query) {
   switch (query.kind) {
     case "start":
       return compileAggregateStart(projectId, query);
+    case "refs":
+      return compileAggregateRefs(projectId, query);
     case "filter":
       return compileAggregateWhere(projectId, query.input, compilePredicate(query.predicate));
     case "text": {
@@ -11472,7 +11552,7 @@ function compileAggregateSource(projectId, query) {
     case "page":
       return compileRowQueryAggregateSource(projectId, query);
     case "vector":
-      throw new Error(`[SixbPg] PostgreSQL object storage does not support query node 'vector'`);
+      throw new Error(`[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`);
   }
 }
 function compileAggregateStart(projectId, query) {
@@ -11488,6 +11568,27 @@ function compileAggregateStart(projectId, query) {
     args: [projectId, query.objectTypeId]
   };
 }
+function compileAggregateRefs(projectId, query) {
+  if (query.refs.length === 0) {
+    throw new Error("[SixbPg] PostgreSQL object storage requires at least one ref");
+  }
+  return {
+    sql: `
+      SELECT selected.project_id, selected.object_type_id, selected.primary_id, selected.properties
+      FROM (
+        SELECT DISTINCT
+          ref.value ->> 'objectTypeId' AS object_type_id,
+          ref.value ->> 'primaryId' AS primary_id
+        FROM jsonb_array_elements(?::text::jsonb) AS ref(value)
+      ) AS requested
+      JOIN objects AS selected
+        ON selected.project_id = ?
+       AND selected.object_type_id = requested.object_type_id
+       AND selected.primary_id = requested.primary_id
+    `,
+    args: [JSON.stringify(query.refs), projectId]
+  };
+}
 function compileAggregateWhere(projectId, inputQuery, predicate) {
   const input = compileAggregateSource(projectId, inputQuery);
   return {
@@ -12033,6 +12134,7 @@ var PG_OBJECT_QUERY_CAPABILITIES = {
   facetObjects: true,
   nodes: {
     start: true,
+    refs: true,
     filter: true,
     text: true,
     sort: true,
@@ -12084,7 +12186,7 @@ var PG_OBJECT_QUERY_CAPABILITIES = {
     stablePageTokens: true
   },
   notes: [
-    "PostgreSQL object query pushdown supports start/filter/text/sort/limit/page/traverse/set/project/expand over JSONB properties and object links.",
+    "PostgreSQL object query pushdown supports start/refs/filter/text/sort/limit/page/traverse/set/project/expand over JSONB properties and object links.",
     "expand hydrates linked objects in-database (top-N per parent via LATERAL + jsonb_agg); core resolves each expansion's cardinality before pushdown, and a mixed/unresolved one stays on the fallback.",
     "Exact decimal predicates, ordering, and keyset pagination use PostgreSQL numeric casts.",
     "Relevance sorting, vector search, and unresolved start.includeSubtypes remain planner fallback or rejection cases."
@@ -12171,7 +12273,7 @@ class PgObjectStorage {
       return result;
     const rows = await valuesJoin(this.sql, "SELECT o.* FROM objects o", ["object_type_id", "primary_id"], params.items.map((i) => [i.objectTypeId, i.primaryId]), `WHERE o.project_id = $1`, [params.projectId]);
     for (const row of rows) {
-      result.set(`${row.object_type_id}:${row.primary_id}`, rowToObject(row));
+      result.set(objectBatchKey(row.object_type_id, row.primary_id), rowToObject(row));
     }
     return result;
   }
@@ -12181,13 +12283,73 @@ class PgObjectStorage {
       return result;
     const rows = await valuesJoin(this.sql, "SELECT l.* FROM links l", ["source_type_id", "source_id", "link_id"], params.items.map((i) => [i.objectTypeId, i.objectId, i.linkId]), `WHERE l.project_id = $1`, [params.projectId]);
     for (const row of rows) {
-      const key = `${row.source_type_id}:${row.source_id}:${row.link_id}`;
+      const key = linkBatchKey(row.source_type_id, row.source_id, row.link_id);
       const existing = result.get(key) ?? [];
       existing.push(rowToLink(row));
       result.set(key, existing);
     }
     return result;
   }
+  async queryLinks(params) {
+    assertLinkQueryLimit(params.limit);
+    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+      return { links: [], hasMore: false };
+    }
+    const args = [JSON.stringify(params.objectRefs), params.projectId];
+    const addArg = (value) => {
+      args.push(value);
+      return `$${args.length}`;
+    };
+    const sourceJoin = `
+      SELECT link.*
+      FROM links AS link
+      JOIN requested
+        ON requested.object_type_id = link.source_type_id
+       AND requested.object_id = link.source_id
+      WHERE link.project_id = $2
+    `;
+    const targetJoin = `
+      SELECT link.*
+      FROM links AS link
+      JOIN requested
+        ON requested.object_type_id = link.target_type_id
+       AND requested.object_id = link.target_id
+      WHERE link.project_id = $2
+    `;
+    const incidentSql = params.direction === "outgoing" ? sourceJoin : params.direction === "incoming" ? targetJoin : `${sourceJoin} UNION ${targetJoin}`;
+    const predicates = [];
+    if (params.linkId !== undefined) {
+      predicates.push(`link_id = ${addArg(params.linkId)}::text`);
+    }
+    if (params.endpointObjectTypeIds !== undefined) {
+      const allowedTypes = addArg(JSON.stringify([...new Set(params.endpointObjectTypeIds)]));
+      predicates.push(`source_type_id IN (SELECT jsonb_array_elements_text(${allowedTypes}::text::jsonb))`, `target_type_id IN (SELECT jsonb_array_elements_text(${allowedTypes}::text::jsonb))`);
+    }
+    if (params.after) {
+      const cursor = params.after.map((value) => `${addArg(value)}::text`);
+      predicates.push(`(source_type_id, source_id, link_id, target_type_id, target_id) > (${cursor.join(", ")})`);
+    }
+    const limit = addArg(params.limit + 1);
+    const whereSql = predicates.length > 0 ? `WHERE ${predicates.join(" AND ")}` : "";
+    const rows = await this.sql.unsafe(`
+        WITH requested AS (
+          SELECT DISTINCT
+            requested."objectTypeId" AS object_type_id,
+            requested."primaryId" AS object_id
+          FROM jsonb_to_recordset($1::text::jsonb)
+            AS requested("objectTypeId" text, "primaryId" text)
+        ), incident AS (${incidentSql})
+        SELECT *
+        FROM incident
+        ${whereSql}
+        ORDER BY source_type_id, source_id, link_id, target_type_id, target_id
+        LIMIT ${limit}
+      `, args);
+    return {
+      links: rows.slice(0, params.limit).map((row) => rowToLink(row)),
+      hasMore: rows.length > params.limit
+    };
+  }
   async listIncidentLinksBatch(params) {
     if (params.items.length === 0)
       return [];
@@ -12197,7 +12359,7 @@ class PgObjectStorage {
     const deduped = new Map;
     for (const row of [...sourceRows, ...targetRows]) {
       const link = rowToLink(row);
-      deduped.set(`${link.sourceTypeId}:${link.sourceId}:${link.linkId}:${link.targetTypeId}:${link.targetId}`, link);
+      deduped.set(linkIdentity(link), link);
     }
     return [...deduped.values()];
   }
@@ -12379,6 +12541,20 @@ function rowToLink(row) {
     lastCommitId: row.last_commit_id
   };
 }
+function linkIdentity(link) {
+  return JSON.stringify([
+    link.sourceTypeId,
+    link.sourceId,
+    link.linkId,
+    link.targetTypeId,
+    link.targetId
+  ]);
+}
+function assertLinkQueryLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object link query limit must be a positive safe integer.");
+  }
+}
 
 // src/pg-pipeline-run-storage.ts
 import { parseSixbFailure as parseSixbFailure3, serializeSixbFailure as serializeSixbFailure3 } from "@sixb/core/internal/errors";
@@ -15170,4 +15346,4 @@ export {
   PostgresStorage
 };
 
-//# debugId=687ACDC68EF0C51B64756E2164756E21
+//# debugId=0531F72AD7BC178764756E2164756E21