@inkeep/agents-api 0.0.0-dev-20260204075611 → 0.0.0-dev-20260204152302

package/dist/.well-known/workflow/v1/step.cjs

@@ -179902,107 +179902,202 @@ function getConversationId() {
 }
 __name(getConversationId, "getConversationId");
 
-// ../packages/agents-core/dist/data-access/manage/contextConfigs.js
-var getContextConfigById = /* @__PURE__ */ __name((db) => async (params) => {
-  return await db.query.contextConfigs.findFirst({
-    where: and(eq(contextConfigs.tenantId, params.scopes.tenantId), eq(contextConfigs.projectId, params.scopes.projectId), eq(contextConfigs.agentId, params.scopes.agentId), eq(contextConfigs.id, params.id))
+// ../packages/agents-core/dist/dolt/merge.js
+var doltMerge = /* @__PURE__ */ __name((db) => async (params) => {
+  console.log("merging branch", params.fromBranch, "into", params.toBranch);
+  await doltCheckout(db)({
+    branch: params.toBranch
   });
-}, "getContextConfigById");
-
-// ../packages/agents-core/dist/data-access/manage/externalAgents.js
-var getExternalAgent = /* @__PURE__ */ __name((db) => async (params) => {
-  return await db.query.externalAgents.findFirst({
-    where: and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId), eq(externalAgents.id, params.externalAgentId))
-  }) || null;
-}, "getExternalAgent");
-
-// ../packages/agents-core/dist/data-access/manage/functions.js
-var getFunction = /* @__PURE__ */ __name((db) => async (params) => {
-  const { functionId, scopes } = params;
-  const { tenantId, projectId } = scopes;
-  return (await db.select().from(functions).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId), eq(functions.id, functionId))).limit(1))[0] || null;
-}, "getFunction");
-
-// ../packages/agents-core/dist/data-access/manage/functionTools.js
-var logger9 = getLogger("functionTools");
-var listFunctionTools = /* @__PURE__ */ __name((db) => async (params) => {
-  const page = params.pagination?.page || 1;
-  const limit3 = Math.min(params.pagination?.limit || 10, 100);
-  const offset = (page - 1) * limit3;
-  const whereClause = and(eq(functionTools.tenantId, params.scopes.tenantId), eq(functionTools.projectId, params.scopes.projectId), eq(functionTools.agentId, params.scopes.agentId));
-  const [functionToolsDbResults, totalResult] = await Promise.all([
-    db.select().from(functionTools).where(whereClause).limit(limit3).offset(offset).orderBy(desc(functionTools.createdAt)),
-    db.select({
-      count: count()
-    }).from(functionTools).where(whereClause)
-  ]);
-  const total = totalResult[0]?.count || 0;
+  const toHead = (await db.execute(sql`SELECT HASHOF('HEAD') as hash`)).rows[0]?.hash;
+  const args2 = [
+    `'${params.fromBranch}'`
+  ];
+  if (params.noFastForward) args2.push("'--no-ff'");
+  if (params.message) args2.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
+  if (params.author) args2.push("'--author'", `'${params.author.name} <${params.author.email}>'`);
+  const firstRow = (await db.execute(sql.raw(`SELECT DOLT_MERGE(${args2.join(", ")})`))).rows[0] ?? {};
+  const mergeResult = typeof firstRow.conflicts === "number" || typeof firstRow.conflicts === "string" || firstRow.conflicts == null ? firstRow : Object.values(firstRow)[0] ?? {};
+  const conflicts = Number(mergeResult.conflicts ?? 0);
+  if (Number.isFinite(conflicts) && conflicts > 0) return {
+    status: "conflicts",
+    from: params.fromBranch,
+    to: params.toBranch,
+    toHead,
+    hasConflicts: true
+  };
   return {
-    data: functionToolsDbResults,
-    pagination: {
-      page,
-      limit: limit3,
-      total,
-      pages: Math.ceil(total / limit3)
-    }
+    status: "success",
+    from: params.fromBranch,
+    to: params.toBranch,
+    toHead,
+    hasConflicts: false
   };
-}, "listFunctionTools");
+}, "doltMerge");
+var doltAbortMerge = /* @__PURE__ */ __name((db) => async () => {
+  await db.execute(sql.raw(`SELECT DOLT_MERGE('--abort')`));
+}, "doltAbortMerge");
 
-// ../packages/agents-core/dist/data-access/manage/subAgentExternalAgentRelations.js
-var getSubAgentExternalAgentRelationsByAgent = /* @__PURE__ */ __name((db) => async (params) => {
-  return await db.query.subAgentExternalAgentRelations.findMany({
-    where: and(eq(subAgentExternalAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentExternalAgentRelations.projectId, params.scopes.projectId), eq(subAgentExternalAgentRelations.agentId, params.scopes.agentId))
+// ../packages/agents-core/dist/dolt/schema-sync.js
+var import_node_crypto3 = require("node:crypto");
+var SCHEMA_SOURCE_BRANCH = "main";
+var getActiveBranch = /* @__PURE__ */ __name((db) => async () => {
+  return (await db.execute(sql`SELECT active_branch() as branch`)).rows[0]?.branch;
+}, "getActiveBranch");
+var getSchemaDiff = /* @__PURE__ */ __name((db) => async (targetBranch) => {
+  return (await db.execute(sql.raw(`SELECT * FROM dolt_schema_diff('${targetBranch}', '${SCHEMA_SOURCE_BRANCH}')`))).rows.map((row) => ({
+    fromTableName: row.from_table_name,
+    toTableName: row.to_table_name,
+    fromCreateStatement: row.from_create_statement,
+    toCreateStatement: row.to_create_statement
+  }));
+}, "getSchemaDiff");
+var hasUncommittedChanges = /* @__PURE__ */ __name((db) => async () => {
+  return (await doltStatus(db)()).length > 0;
+}, "hasUncommittedChanges");
+var commitPendingChanges = /* @__PURE__ */ __name((db) => async (options) => {
+  const message = options.message ?? "Auto-commit pending changes before schema sync";
+  await doltAddAndCommit(db)({
+    message,
+    author: options.author
   });
-}, "getSubAgentExternalAgentRelationsByAgent");
-
-// ../packages/agents-core/dist/data-access/manage/subAgentRelations.js
-var getAgentRelationsByAgent = /* @__PURE__ */ __name((db) => async (params) => {
-  return await db.query.subAgentRelations.findMany({
-    where: and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId))
+}, "commitPendingChanges");
+var SCHEMA_SYNC_LOCK_PREFIX = "schema_sync_";
+var getSchemaSyncLockKey = /* @__PURE__ */ __name((branchName) => {
+  const lockKey = `${SCHEMA_SYNC_LOCK_PREFIX}${branchName}`;
+  return (0, import_node_crypto3.createHash)("sha256").update(lockKey).digest().readBigInt64BE(0);
+}, "getSchemaSyncLockKey");
+var tryAcquireSchemaSyncLock = /* @__PURE__ */ __name((db) => async (branchName) => {
+  const key = getSchemaSyncLockKey(branchName);
+  return (await db.execute(sql`SELECT pg_try_advisory_lock(CAST(${key} AS bigint)) as acquired`)).rows[0]?.acquired === true;
+}, "tryAcquireSchemaSyncLock");
+var releaseSchemaSyncLock = /* @__PURE__ */ __name((db) => async (branchName) => {
+  const key = getSchemaSyncLockKey(branchName);
+  await db.execute(sql`SELECT pg_advisory_unlock(CAST(${key} AS bigint))`);
+}, "releaseSchemaSyncLock");
+var getLatestCommitHash = /* @__PURE__ */ __name((db) => async () => {
+  return (await db.execute(sql`SELECT commit_hash FROM dolt_log LIMIT 1`)).rows[0]?.commit_hash;
+}, "getLatestCommitHash");
+var syncSchemaFromMain = /* @__PURE__ */ __name((db) => async (options = {}) => {
+  const currentBranch = await getActiveBranch(db)();
+  if (currentBranch === SCHEMA_SOURCE_BRANCH) return {
+    synced: true,
+    hadDifferences: false,
+    error: "Cannot sync schema: already on schema source branch"
+  };
+  if (!await tryAcquireSchemaSyncLock(db)(currentBranch)) return {
+    synced: false,
+    hadDifferences: true,
+    skippedDueToLock: true
+  };
+  try {
+    const differences = await getSchemaDiff(db)(currentBranch);
+    if (differences.length === 0) return {
+      synced: false,
+      hadDifferences: false
+    };
+    if (await hasUncommittedChanges(db)()) if (options.autoCommitPending) await commitPendingChanges(db)({
+      message: "Auto-commit pending changes before schema sync",
+      author: options.author
+    });
+    else return {
+      synced: false,
+      hadDifferences: true,
+      differences,
+      error: "Cannot sync schema: uncommitted changes exist. Commit changes first or set autoCommitPending: true"
+    };
+    const mergeSchemaMessage = `Synced schema from ${SCHEMA_SOURCE_BRANCH}`;
+    if ((await doltMerge(db)({
+      fromBranch: SCHEMA_SOURCE_BRANCH,
+      toBranch: currentBranch,
+      message: mergeSchemaMessage,
+      noFastForward: true,
+      author: {
+        name: "Schema Sync System",
+        email: "system@inkeep.com"
+      }
+    })).status === "conflicts") {
+      await doltAbortMerge(db)();
+      return {
+        synced: false,
+        hadDifferences: true,
+        differences,
+        error: "Schema merge produced conflicts that require manual resolution. Merge has been aborted."
+      };
+    }
+    return {
+      synced: true,
+      hadDifferences: true,
+      differences,
+      mergeCommitHash: await getLatestCommitHash(db)()
+    };
+  } catch (error46) {
+    try {
+      await doltAbortMerge(db)();
+    } catch {
+    }
+    return {
+      synced: false,
+      hadDifferences: true,
+      error: `Schema sync failed: ${error46 instanceof Error ? error46.message : "Unknown error"}`
+    };
+  } finally {
+    try {
+      await releaseSchemaSyncLock(db)(currentBranch);
+    } catch {
+    }
+  }
+}, "syncSchemaFromMain");
+var ensureSchemaSync = /* @__PURE__ */ __name((db) => async (options = {}) => {
+  const currentBranch = await getActiveBranch(db)();
+  if (currentBranch === SCHEMA_SOURCE_BRANCH) return {
+    synced: false,
+    hadDifferences: false
+  };
+  const differences = await getSchemaDiff(db)(currentBranch);
+  if (differences.length === 0) return {
+    synced: false,
+    hadDifferences: false
+  };
+  if (options.autoSync) return syncSchemaFromMain(db)({
+    autoCommitPending: options.autoCommitPending,
+    commitMessage: options.commitMessage,
+    author: options.author
   });
-}, "getAgentRelationsByAgent");
+  return {
+    synced: false,
+    hadDifferences: true,
+    differences,
+    error: `Branch '${currentBranch}' has ${differences.length} schema difference(s) from '${SCHEMA_SOURCE_BRANCH}'. Set autoSync: true to automatically sync schema.`
+  };
+}, "ensureSchemaSync");
 
-// ../packages/agents-core/dist/data-access/manage/subAgentTeamAgentRelations.js
-var getSubAgentTeamAgentRelationsByAgent = /* @__PURE__ */ __name((db) => async (params) => {
-  return await db.query.subAgentTeamAgentRelations.findMany({
-    where: and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId))
+// ../packages/agents-core/dist/dolt/branches-api.js
+var checkoutBranch = /* @__PURE__ */ __name((db) => async (params) => {
+  const { branchName, syncSchema = true, autoCommitPending = false } = params;
+  const branch = (await doltListBranches(db)()).find((b3) => b3.name === branchName);
+  if (!branch) throw new Error(`Branch '${branchName}' not found`);
+  await doltCheckout(db)({
+    branch: branchName
   });
-}, "getSubAgentTeamAgentRelationsByAgent");
-
-// ../packages/agents-core/dist/dolt/commit.js
-var doltAdd = /* @__PURE__ */ __name((db) => async (params = {}) => {
-  if (!params.tables || params.tables.length === 0) await db.execute(sql`SELECT DOLT_ADD('-A')`);
-  else {
-    const tableParams = params.tables.map((t2) => `'${t2}'`).join(", ");
-    console.log(tableParams);
-    await db.execute(sql.raw(`SELECT DOLT_ADD(${tableParams})`));
-  }
-}, "doltAdd");
-var doltCommit = /* @__PURE__ */ __name((db) => async (params) => {
-  const args2 = [];
-  args2.push("'-a'");
-  args2.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
-  if (params.author) args2.push("'--author'", `'${params.author.name} <${params.author.email}>'`);
-  await db.execute(sql.raw(`SELECT DOLT_COMMIT(${args2.join(", ")})`));
-  return "Commit successful";
-}, "doltCommit");
-var doltAddAndCommit = /* @__PURE__ */ __name((db) => async (params) => {
-  await doltAdd(db)({});
-  return doltCommit(db)(params);
-}, "doltAddAndCommit");
-var doltReset = /* @__PURE__ */ __name((db) => async (params) => {
-  if (params?.hard) await db.execute(sql`SELECT DOLT_RESET('--hard')`);
-  else if (params?.tables && params.tables.length > 0) {
-    const tableParams = params.tables.map((t2) => `'${t2}'`).join(", ");
-    await db.execute(sql.raw(`SELECT DOLT_RESET(${tableParams})`));
-  } else await db.execute(sql`SELECT DOLT_RESET()`);
-}, "doltReset");
-var doltStatus = /* @__PURE__ */ __name((db) => async () => {
-  return (await db.execute(sql`SELECT * FROM dolt_status`)).rows;
-}, "doltStatus");
-var doltListTags = /* @__PURE__ */ __name((db) => async () => {
-  return (await db.execute(sql`SELECT * FROM dolt_tags`)).rows;
-}, "doltListTags");
+  let schemaSyncResult = {
+    synced: false,
+    hadDifferences: false
+  };
+  if (syncSchema && branchName !== SCHEMA_SOURCE_BRANCH) schemaSyncResult = await ensureSchemaSync(db)({
+    autoSync: true,
+    autoCommitPending
+  });
+  return {
+    branchName,
+    hash: (await doltListBranches(db)()).find((b3) => b3.name === branchName)?.hash ?? branch.hash,
+    schemaSync: {
+      performed: schemaSyncResult.synced,
+      hadDifferences: schemaSyncResult.hadDifferences,
+      error: schemaSyncResult.error,
+      mergeCommitHash: schemaSyncResult.mergeCommitHash
+    }
+  };
+}, "checkoutBranch");
 
 // ../packages/agents-core/dist/dolt/ref-helpers.js
 var isValidCommitHash = /* @__PURE__ */ __name((ref) => {
@@ -186985,12 +187080,12 @@ function unsafeStringify(arr, offset = 0) {
 __name(unsafeStringify, "unsafeStringify");
 
 // ../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/rng.js
-var import_node_crypto3 = require("node:crypto");
+var import_node_crypto4 = require("node:crypto");
 var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
 function rng() {
   if (poolPtr > rnds8Pool.length - 16) {
-    (0, import_node_crypto3.randomFillSync)(rnds8Pool);
+    (0, import_node_crypto4.randomFillSync)(rnds8Pool);
     poolPtr = 0;
   }
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
@@ -186998,9 +187093,9 @@ function rng() {
 __name(rng, "rng");
 
 // ../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/native.js
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var native_default = {
-  randomUUID: import_node_crypto4.randomUUID
+  randomUUID: import_node_crypto5.randomUUID
 };
 
 // ../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/v4.js
@@ -195427,8 +195522,8 @@ var Logger = class {
     }
   }
 };
-var logger10 = new Logger();
-var logger_default = logger10;
+var logger9 = new Logger();
+var logger_default = logger9;
 var ComposioError2 = class _ComposioError extends Error {
   static {
     __name(this, "_ComposioError");
@@ -196619,208 +196714,116 @@ var doltCheckout = /* @__PURE__ */ __name((db) => async (params) => {
   params.create ? await db.execute(sql.raw(`SELECT DOLT_CHECKOUT('-b', '${params.branch}')`)) : await db.execute(sql.raw(`SELECT DOLT_CHECKOUT('${params.branch}')`));
 }, "doltCheckout");
 
-// ../packages/agents-core/dist/dolt/merge.js
-var doltMerge = /* @__PURE__ */ __name((db) => async (params) => {
-  console.log("merging branch", params.fromBranch, "into", params.toBranch);
-  await doltCheckout(db)({
-    branch: params.toBranch
-  });
-  const toHead = (await db.execute(sql`SELECT HASHOF('HEAD') as hash`)).rows[0]?.hash;
-  const args2 = [
-    `'${params.fromBranch}'`
-  ];
-  if (params.noFastForward) args2.push("'--no-ff'");
-  if (params.message) args2.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
+// ../packages/agents-core/dist/dolt/commit.js
+var doltAdd = /* @__PURE__ */ __name((db) => async (params = {}) => {
+  if (!params.tables || params.tables.length === 0) await db.execute(sql`SELECT DOLT_ADD('-A')`);
+  else {
+    const tableParams = params.tables.map((t2) => `'${t2}'`).join(", ");
+    console.log(tableParams);
+    await db.execute(sql.raw(`SELECT DOLT_ADD(${tableParams})`));
+  }
+}, "doltAdd");
+var doltCommit = /* @__PURE__ */ __name((db) => async (params) => {
+  const args2 = [];
+  args2.push("'-a'");
+  args2.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
   if (params.author) args2.push("'--author'", `'${params.author.name} <${params.author.email}>'`);
-  const firstRow = (await db.execute(sql.raw(`SELECT DOLT_MERGE(${args2.join(", ")})`))).rows[0] ?? {};
-  const mergeResult = typeof firstRow.conflicts === "number" || typeof firstRow.conflicts === "string" || firstRow.conflicts == null ? firstRow : Object.values(firstRow)[0] ?? {};
-  const conflicts = Number(mergeResult.conflicts ?? 0);
-  if (Number.isFinite(conflicts) && conflicts > 0) return {
-    status: "conflicts",
-    from: params.fromBranch,
-    to: params.toBranch,
-    toHead,
-    hasConflicts: true
-  };
-  return {
-    status: "success",
-    from: params.fromBranch,
-    to: params.toBranch,
-    toHead,
-    hasConflicts: false
-  };
-}, "doltMerge");
-var doltAbortMerge = /* @__PURE__ */ __name((db) => async () => {
-  await db.execute(sql.raw(`SELECT DOLT_MERGE('--abort')`));
-}, "doltAbortMerge");
+  await db.execute(sql.raw(`SELECT DOLT_COMMIT(${args2.join(", ")})`));
+  return "Commit successful";
+}, "doltCommit");
+var doltAddAndCommit = /* @__PURE__ */ __name((db) => async (params) => {
+  await doltAdd(db)({});
+  return doltCommit(db)(params);
+}, "doltAddAndCommit");
+var doltReset = /* @__PURE__ */ __name((db) => async (params) => {
+  if (params?.hard) await db.execute(sql`SELECT DOLT_RESET('--hard')`);
+  else if (params?.tables && params.tables.length > 0) {
+    const tableParams = params.tables.map((t2) => `'${t2}'`).join(", ");
+    await db.execute(sql.raw(`SELECT DOLT_RESET(${tableParams})`));
+  } else await db.execute(sql`SELECT DOLT_RESET()`);
+}, "doltReset");
+var doltStatus = /* @__PURE__ */ __name((db) => async () => {
+  return (await db.execute(sql`SELECT * FROM dolt_status`)).rows;
+}, "doltStatus");
+var doltListTags = /* @__PURE__ */ __name((db) => async () => {
+  return (await db.execute(sql`SELECT * FROM dolt_tags`)).rows;
+}, "doltListTags");
 
-// ../packages/agents-core/dist/dolt/schema-sync.js
-var import_node_crypto5 = require("node:crypto");
-var SCHEMA_SOURCE_BRANCH = "main";
-var getActiveBranch = /* @__PURE__ */ __name((db) => async () => {
-  return (await db.execute(sql`SELECT active_branch() as branch`)).rows[0]?.branch;
-}, "getActiveBranch");
-var getSchemaDiff = /* @__PURE__ */ __name((db) => async (targetBranch) => {
-  return (await db.execute(sql.raw(`SELECT * FROM dolt_schema_diff('${targetBranch}', '${SCHEMA_SOURCE_BRANCH}')`))).rows.map((row) => ({
-    fromTableName: row.from_table_name,
-    toTableName: row.to_table_name,
-    fromCreateStatement: row.from_create_statement,
-    toCreateStatement: row.to_create_statement
-  }));
-}, "getSchemaDiff");
-var hasUncommittedChanges = /* @__PURE__ */ __name((db) => async () => {
-  return (await doltStatus(db)()).length > 0;
-}, "hasUncommittedChanges");
-var commitPendingChanges = /* @__PURE__ */ __name((db) => async (options) => {
-  const message = options.message ?? "Auto-commit pending changes before schema sync";
-  await doltAddAndCommit(db)({
-    message,
-    author: options.author
+// ../packages/agents-core/dist/data-access/manage/projectLifecycle.js
+var logger10 = getLogger("project-lifecycle");
+
+// ../packages/agents-core/dist/data-access/manage/contextConfigs.js
+var getContextConfigById = /* @__PURE__ */ __name((db) => async (params) => {
+  return await db.query.contextConfigs.findFirst({
+    where: and(eq(contextConfigs.tenantId, params.scopes.tenantId), eq(contextConfigs.projectId, params.scopes.projectId), eq(contextConfigs.agentId, params.scopes.agentId), eq(contextConfigs.id, params.id))
   });
-}, "commitPendingChanges");
-var SCHEMA_SYNC_LOCK_PREFIX = "schema_sync_";
-var getSchemaSyncLockKey = /* @__PURE__ */ __name((branchName) => {
-  const lockKey = `${SCHEMA_SYNC_LOCK_PREFIX}${branchName}`;
-  return (0, import_node_crypto5.createHash)("sha256").update(lockKey).digest().readBigInt64BE(0);
-}, "getSchemaSyncLockKey");
-var tryAcquireSchemaSyncLock = /* @__PURE__ */ __name((db) => async (branchName) => {
-  const key = getSchemaSyncLockKey(branchName);
-  return (await db.execute(sql`SELECT pg_try_advisory_lock(CAST(${key} AS bigint)) as acquired`)).rows[0]?.acquired === true;
-}, "tryAcquireSchemaSyncLock");
-var releaseSchemaSyncLock = /* @__PURE__ */ __name((db) => async (branchName) => {
-  const key = getSchemaSyncLockKey(branchName);
-  await db.execute(sql`SELECT pg_advisory_unlock(CAST(${key} AS bigint))`);
-}, "releaseSchemaSyncLock");
-var getLatestCommitHash = /* @__PURE__ */ __name((db) => async () => {
-  return (await db.execute(sql`SELECT commit_hash FROM dolt_log LIMIT 1`)).rows[0]?.commit_hash;
-}, "getLatestCommitHash");
-var syncSchemaFromMain = /* @__PURE__ */ __name((db) => async (options = {}) => {
-  const currentBranch = await getActiveBranch(db)();
-  if (currentBranch === SCHEMA_SOURCE_BRANCH) return {
-    synced: true,
-    hadDifferences: false,
-    error: "Cannot sync schema: already on schema source branch"
-  };
-  if (!await tryAcquireSchemaSyncLock(db)(currentBranch)) return {
-    synced: false,
-    hadDifferences: true,
-    skippedDueToLock: true
-  };
-  try {
-    const differences = await getSchemaDiff(db)(currentBranch);
-    if (differences.length === 0) return {
-      synced: false,
-      hadDifferences: false
-    };
-    if (await hasUncommittedChanges(db)()) if (options.autoCommitPending) await commitPendingChanges(db)({
-      message: "Auto-commit pending changes before schema sync",
-      author: options.author
-    });
-    else return {
-      synced: false,
-      hadDifferences: true,
-      differences,
-      error: "Cannot sync schema: uncommitted changes exist. Commit changes first or set autoCommitPending: true"
-    };
-    const mergeSchemaMessage = `Synced schema from ${SCHEMA_SOURCE_BRANCH}`;
-    if ((await doltMerge(db)({
-      fromBranch: SCHEMA_SOURCE_BRANCH,
-      toBranch: currentBranch,
-      message: mergeSchemaMessage,
-      noFastForward: true,
-      author: {
-        name: "Schema Sync System",
-        email: "system@inkeep.com"
-      }
-    })).status === "conflicts") {
-      await doltAbortMerge(db)();
-      return {
-        synced: false,
-        hadDifferences: true,
-        differences,
-        error: "Schema merge produced conflicts that require manual resolution. Merge has been aborted."
-      };
-    }
-    return {
-      synced: true,
-      hadDifferences: true,
-      differences,
-      mergeCommitHash: await getLatestCommitHash(db)()
-    };
-  } catch (error46) {
-    try {
-      await doltAbortMerge(db)();
-    } catch {
-    }
-    return {
-      synced: false,
-      hadDifferences: true,
-      error: `Schema sync failed: ${error46 instanceof Error ? error46.message : "Unknown error"}`
-    };
-  } finally {
-    try {
-      await releaseSchemaSyncLock(db)(currentBranch);
-    } catch {
+}, "getContextConfigById");
+
+// ../packages/agents-core/dist/data-access/manage/externalAgents.js
+var getExternalAgent = /* @__PURE__ */ __name((db) => async (params) => {
+  return await db.query.externalAgents.findFirst({
+    where: and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId), eq(externalAgents.id, params.externalAgentId))
+  }) || null;
+}, "getExternalAgent");
+
+// ../packages/agents-core/dist/data-access/manage/functions.js
+var getFunction = /* @__PURE__ */ __name((db) => async (params) => {
+  const { functionId, scopes } = params;
+  const { tenantId, projectId } = scopes;
+  return (await db.select().from(functions).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId), eq(functions.id, functionId))).limit(1))[0] || null;
+}, "getFunction");
+
+// ../packages/agents-core/dist/data-access/manage/functionTools.js
+var logger11 = getLogger("functionTools");
+var listFunctionTools = /* @__PURE__ */ __name((db) => async (params) => {
+  const page = params.pagination?.page || 1;
+  const limit3 = Math.min(params.pagination?.limit || 10, 100);
+  const offset = (page - 1) * limit3;
+  const whereClause = and(eq(functionTools.tenantId, params.scopes.tenantId), eq(functionTools.projectId, params.scopes.projectId), eq(functionTools.agentId, params.scopes.agentId));
+  const [functionToolsDbResults, totalResult] = await Promise.all([
+    db.select().from(functionTools).where(whereClause).limit(limit3).offset(offset).orderBy(desc(functionTools.createdAt)),
+    db.select({
+      count: count()
+    }).from(functionTools).where(whereClause)
+  ]);
+  const total = totalResult[0]?.count || 0;
+  return {
+    data: functionToolsDbResults,
+    pagination: {
+      page,
+      limit: limit3,
+      total,
+      pages: Math.ceil(total / limit3)
     }
-  }
-}, "syncSchemaFromMain");
-var ensureSchemaSync = /* @__PURE__ */ __name((db) => async (options = {}) => {
-  const currentBranch = await getActiveBranch(db)();
-  if (currentBranch === SCHEMA_SOURCE_BRANCH) return {
-    synced: false,
-    hadDifferences: false
   };
-  const differences = await getSchemaDiff(db)(currentBranch);
-  if (differences.length === 0) return {
-    synced: false,
-    hadDifferences: false
-  };
-  if (options.autoSync) return syncSchemaFromMain(db)({
-    autoCommitPending: options.autoCommitPending,
-    commitMessage: options.commitMessage,
-    author: options.author
+}, "listFunctionTools");
+
+// ../packages/agents-core/dist/data-access/manage/subAgentExternalAgentRelations.js
+var getSubAgentExternalAgentRelationsByAgent = /* @__PURE__ */ __name((db) => async (params) => {
+  return await db.query.subAgentExternalAgentRelations.findMany({
+    where: and(eq(subAgentExternalAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentExternalAgentRelations.projectId, params.scopes.projectId), eq(subAgentExternalAgentRelations.agentId, params.scopes.agentId))
   });
-  return {
-    synced: false,
-    hadDifferences: true,
-    differences,
-    error: `Branch '${currentBranch}' has ${differences.length} schema difference(s) from '${SCHEMA_SOURCE_BRANCH}'. Set autoSync: true to automatically sync schema.`
-  };
-}, "ensureSchemaSync");
+}, "getSubAgentExternalAgentRelationsByAgent");
 
-// ../packages/agents-core/dist/dolt/branches-api.js
-var checkoutBranch = /* @__PURE__ */ __name((db) => async (params) => {
-  const { branchName, syncSchema = true, autoCommitPending = false } = params;
-  const branch = (await doltListBranches(db)()).find((b3) => b3.name === branchName);
-  if (!branch) throw new Error(`Branch '${branchName}' not found`);
-  await doltCheckout(db)({
-    branch: branchName
+// ../packages/agents-core/dist/data-access/manage/subAgentRelations.js
+var getAgentRelationsByAgent = /* @__PURE__ */ __name((db) => async (params) => {
+  return await db.query.subAgentRelations.findMany({
+    where: and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId))
   });
-  let schemaSyncResult = {
-    synced: false,
-    hadDifferences: false
-  };
-  if (syncSchema && branchName !== SCHEMA_SOURCE_BRANCH) schemaSyncResult = await ensureSchemaSync(db)({
-    autoSync: true,
-    autoCommitPending
+}, "getAgentRelationsByAgent");
+
+// ../packages/agents-core/dist/data-access/manage/subAgentTeamAgentRelations.js
+var getSubAgentTeamAgentRelationsByAgent = /* @__PURE__ */ __name((db) => async (params) => {
+  return await db.query.subAgentTeamAgentRelations.findMany({
+    where: and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId))
   });
-  return {
-    branchName,
-    hash: (await doltListBranches(db)()).find((b3) => b3.name === branchName)?.hash ?? branch.hash,
-    schemaSync: {
-      performed: schemaSyncResult.synced,
-      hadDifferences: schemaSyncResult.hadDifferences,
-      error: schemaSyncResult.error,
-      mergeCommitHash: schemaSyncResult.mergeCommitHash
-    }
-  };
-}, "checkoutBranch");
+}, "getSubAgentTeamAgentRelationsByAgent");
 
 // ../packages/agents-core/dist/utils/apiKeys.js
 var import_node_crypto6 = require("node:crypto");
 var import_node_util2 = require("node:util");
 var scryptAsync = (0, import_node_util2.promisify)(import_node_crypto6.scrypt);
-var logger11 = getLogger("api-key");
+var logger12 = getLogger("api-key");
 var generatePublicId = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-", 12);
 
 // ../packages/agents-core/dist/utils/error.js
@@ -196973,7 +196976,7 @@ var commonDeleteErrorResponses = {
 
 // ../packages/agents-core/dist/utils/JsonTransformer.js
 var jmespath2 = __toESM(require_jmespath(), 1);
-var logger12 = getLogger("JsonTransformer");
+var logger13 = getLogger("JsonTransformer");
 
 // ../packages/agents-core/dist/utils/json-parser.js
 var import_traverse = __toESM(require_traverse(), 1);
@@ -227410,7 +227413,7 @@ var openrouter = createOpenRouter({
 });
 
 // ../packages/agents-core/dist/utils/model-factory.js
-var logger13 = getLogger("ModelFactory");
+var logger14 = getLogger("ModelFactory");
 var nimDefault = createOpenAICompatible({
   name: "nim",
   baseURL: "https://integrate.api.nvidia.com/v1",
@@ -227466,7 +227469,7 @@ var ModelFactory = class ModelFactory2 {
           },
           ...config3
         };
-        logger13.info({
+        logger14.info({
           config: {
             baseURL: customConfig.baseURL,
             hasApiKey: !!process.env.CUSTOM_LLM_API_KEY,
@@ -227506,7 +227509,7 @@ var ModelFactory = class ModelFactory2 {
     if (!modelSettings.model) throw new Error("Model configuration is required");
     const modelString = modelSettings.model.trim();
     const { provider, modelName } = ModelFactory2.parseModelString(modelString);
-    logger13.debug({
+    logger14.debug({
       provider,
       model: modelName,
       fullModelString: modelSettings.model,
@@ -227514,7 +227517,7 @@ var ModelFactory = class ModelFactory2 {
     }, "Creating language model from config");
     const providerConfig = ModelFactory2.extractProviderConfig(modelSettings.providerOptions);
     if (provider === "azure" || Object.keys(providerConfig).length > 0) {
-      logger13.info({
+      logger14.info({
         config: providerConfig
       }, `Applying custom ${provider} provider configuration`);
       return ModelFactory2.createProvider(provider, providerConfig).languageModel(modelName);
@@ -227631,13 +227634,13 @@ var ModelFactory = class ModelFactory2 {
 };
 
 // ../packages/agents-core/dist/utils/service-token-auth.js
-var logger14 = getLogger("service-token-auth");
+var logger15 = getLogger("service-token-auth");
 
 // ../packages/agents-core/dist/utils/third-party-mcp-servers/composio-client.js
 var logger$1 = getLogger("composio-client");
 
 // ../packages/agents-core/dist/utils/third-party-mcp-servers/third-party-check.js
-var logger15 = getLogger("third-party-check");
+var logger16 = getLogger("third-party-check");
 
 // ../packages/agents-core/dist/utils/trigger-auth.js
 var import_node_crypto7 = require("node:crypto");
@@ -227645,10 +227648,10 @@ var import_node_util3 = require("node:util");
 var scryptAsync2 = (0, import_node_util3.promisify)(import_node_crypto7.scrypt);
 
 // ../packages/agents-core/dist/utils/tracer-factory.js
-var logger16 = getLogger("tracer");
+var logger17 = getLogger("tracer");
 
 // ../packages/agents-core/dist/data-access/manage/tools.js
-var logger17 = getLogger("tools");
+var logger18 = getLogger("tools");
 var listTools = /* @__PURE__ */ __name((db) => async (params) => {
   const page = params.pagination?.page || 1;
   const limit3 = Math.min(params.pagination?.limit || 10, 100);
@@ -227685,6 +227688,7 @@ var getAgentById = /* @__PURE__ */ __name((db) => async (params) => {
     where: and(eq(agents.tenantId, params.scopes.tenantId), eq(agents.projectId, params.scopes.projectId), eq(agents.id, params.scopes.agentId))
   }) ?? null;
 }, "getAgentById");
+var agentsLogger = getLogger("agents-data-access");
 var fetchComponentRelationships = /* @__PURE__ */ __name((db) => async (scopes, subAgentIds, config3) => {
   const componentsObject = {};
   if (subAgentIds.length > 0) {
@@ -228158,9 +228162,6 @@ var getEvaluationJobConfigEvaluatorRelations = /* @__PURE__ */ __name((db) => as
 // ../packages/agents-core/dist/data-access/manage/projectFull.js
 var defaultLogger2 = getLogger("projectFull");
 
-// ../packages/agents-core/dist/data-access/manage/projectLifecycle.js
-var logger18 = getLogger("project-lifecycle");
-
 // ../packages/agents-core/dist/data-access/runtime/conversations.js
 var getConversation = /* @__PURE__ */ __name((db) => async (params) => {
   return await db.query.conversations.findFirst({