@inkeep/agents-core 0.41.2 → 0.42.0

package/dist/db/runtime/runtime-schema.js

@@ -0,0 +1,483 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.js";
+import { account, deviceCode, invitation, member, organization, session, ssoProvider, user, verification } from "../../auth/auth-schema.js";
+import { relations } from "drizzle-orm";
+import { foreignKey, index, jsonb, pgTable, primaryKey, text, timestamp, unique, varchar } from "drizzle-orm/pg-core";
+
+//#region src/db/runtime/runtime-schema.ts
+var runtime_schema_exports = /* @__PURE__ */ __exportAll({
+	account: () => account,
+	apiKeys: () => apiKeys,
+	contextCache: () => contextCache,
+	conversations: () => conversations,
+	conversationsRelations: () => conversationsRelations,
+	datasetRun: () => datasetRun,
+	datasetRunConversationRelations: () => datasetRunConversationRelations,
+	deviceCode: () => deviceCode,
+	evaluationResult: () => evaluationResult,
+	evaluationRun: () => evaluationRun,
+	invitation: () => invitation,
+	ledgerArtifacts: () => ledgerArtifacts,
+	ledgerArtifactsRelations: () => ledgerArtifactsRelations,
+	member: () => member,
+	messages: () => messages,
+	messagesRelations: () => messagesRelations,
+	organization: () => organization,
+	projectMetadata: () => projectMetadata,
+	session: () => session,
+	ssoProvider: () => ssoProvider,
+	taskRelations: () => taskRelations,
+	taskRelationsRelations: () => taskRelationsRelations,
+	tasks: () => tasks,
+	tasksRelations: () => tasksRelations,
+	triggerInvocations: () => triggerInvocations,
+	user: () => user,
+	verification: () => verification
+});
+const projectScoped = {
+	tenantId: varchar("tenant_id", { length: 256 }).notNull(),
+	id: varchar("id", { length: 256 }).notNull(),
+	projectId: varchar("project_id", { length: 256 }).notNull()
+};
+const agentScoped = {
+	...projectScoped,
+	agentId: varchar("agent_id", { length: 256 }).notNull()
+};
+const subAgentScoped = {
+	...agentScoped,
+	subAgentId: varchar("sub_agent_id", { length: 256 }).notNull()
+};
+const timestamps = {
+	createdAt: timestamp("created_at", { mode: "string" }).notNull().defaultNow(),
+	updatedAt: timestamp("updated_at", { mode: "string" }).notNull().defaultNow()
+};
+/**
+* Runtime projects table - source of truth for which projects exist in a tenant.
+* This is NOT versioned - project existence is tracked here while
+* project configuration/content lives in the versioned config DB.
+*
+* Named 'project_metadata' to avoid conflict with the manage-schema 'projects' table.
+*/
+const projectMetadata = pgTable("project_metadata", {
+	id: varchar("id", { length: 256 }).notNull(),
+	tenantId: varchar("tenant_id", { length: 256 }).notNull(),
+	createdAt: timestamp("created_at", { mode: "string" }).notNull().defaultNow(),
+	createdBy: varchar("created_by", { length: 256 }),
+	mainBranchName: varchar("main_branch_name", { length: 512 }).notNull()
+}, (table) => [
+	primaryKey({ columns: [table.tenantId, table.id] }),
+	index("project_metadata_tenant_idx").on(table.tenantId),
+	index("project_metadata_main_branch_idx").on(table.mainBranchName),
+	foreignKey({
+		columns: [table.tenantId],
+		foreignColumns: [organization.id],
+		name: "project_metadata_organization_fk"
+	}).onDelete("cascade")
+]);
+const conversations = pgTable("conversations", {
+	...projectScoped,
+	userId: varchar("user_id", { length: 256 }),
+	agentId: varchar("agent_id", { length: 256 }),
+	activeSubAgentId: varchar("active_sub_agent_id", { length: 256 }).notNull(),
+	ref: jsonb("ref").$type(),
+	title: text("title"),
+	lastContextResolution: timestamp("last_context_resolution", { mode: "string" }),
+	metadata: jsonb("metadata").$type(),
+	...timestamps
+}, (table) => [primaryKey({ columns: [
+	table.tenantId,
+	table.projectId,
+	table.id
+] })]);
+const tasks = pgTable("tasks", {
+	...subAgentScoped,
+	contextId: varchar("context_id", { length: 256 }).notNull(),
+	ref: jsonb("ref").$type(),
+	status: varchar("status", { length: 256 }).notNull(),
+	metadata: jsonb("metadata").$type(),
+	...timestamps
+}, (table) => [primaryKey({ columns: [
+	table.tenantId,
+	table.projectId,
+	table.id
+] })]);
+const apiKeys = pgTable("api_keys", {
+	...projectScoped,
+	agentId: varchar("agent_id", { length: 256 }).notNull(),
+	publicId: varchar("public_id", { length: 256 }).notNull().unique(),
+	keyHash: varchar("key_hash", { length: 256 }).notNull(),
+	keyPrefix: varchar("key_prefix", { length: 256 }).notNull(),
+	name: varchar("name", { length: 256 }),
+	lastUsedAt: timestamp("last_used_at", { mode: "string" }),
+	expiresAt: timestamp("expires_at", { mode: "string" }),
+	...timestamps
+}, (t) => [
+	foreignKey({
+		columns: [t.tenantId],
+		foreignColumns: [organization.id],
+		name: "api_keys_organization_fk"
+	}).onDelete("cascade"),
+	index("api_keys_tenant_agent_idx").on(t.tenantId, t.agentId),
+	index("api_keys_prefix_idx").on(t.keyPrefix),
+	index("api_keys_public_id_idx").on(t.publicId)
+]);
+/**
+* Trigger invocations - records each time a webhook trigger is invoked.
+* This is runtime data (transactional) so it lives in PostgreSQL, not DoltGres.
+* NOTE: No FK to triggers table since triggers is in a different database (DoltGres).
+* Application code must enforce referential integrity for triggerId.
+* Can optionally link to conversations when the trigger creates one.
+*/
+const triggerInvocations = pgTable("trigger_invocations", {
+	...agentScoped,
+	triggerId: varchar("trigger_id", { length: 256 }).notNull(),
+	conversationId: varchar("conversation_id", { length: 256 }),
+	status: varchar("status", { length: 20 }).notNull().default("pending"),
+	requestPayload: jsonb("request_payload").notNull(),
+	transformedPayload: jsonb("transformed_payload"),
+	errorMessage: text("error_message"),
+	createdAt: timestamp("created_at", { mode: "string" }).notNull().defaultNow()
+}, (table) => [
+	primaryKey({ columns: [
+		table.tenantId,
+		table.projectId,
+		table.agentId,
+		table.id
+	] }),
+	index("trigger_invocations_trigger_idx").on(table.triggerId, table.createdAt),
+	index("trigger_invocations_status_idx").on(table.triggerId, table.status)
+]);
+const messages = pgTable("messages", {
+	...projectScoped,
+	conversationId: varchar("conversation_id", { length: 256 }).notNull(),
+	role: varchar("role", { length: 256 }).notNull(),
+	fromSubAgentId: varchar("from_sub_agent_id", { length: 256 }),
+	toSubAgentId: varchar("to_sub_agent_id", { length: 256 }),
+	fromExternalAgentId: varchar("from_external_sub_agent_id", { length: 256 }),
+	toExternalAgentId: varchar("to_external_sub_agent_id", { length: 256 }),
+	fromTeamAgentId: varchar("from_team_agent_id", { length: 256 }),
+	toTeamAgentId: varchar("to_team_agent_id", { length: 256 }),
+	content: jsonb("content").$type().notNull(),
+	visibility: varchar("visibility", { length: 256 }).notNull().default("user-facing"),
+	messageType: varchar("message_type", { length: 256 }).notNull().default("chat"),
+	taskId: varchar("task_id", { length: 256 }),
+	parentMessageId: varchar("parent_message_id", { length: 256 }),
+	a2aTaskId: varchar("a2a_task_id", { length: 256 }),
+	a2aSessionId: varchar("a2a_session_id", { length: 256 }),
+	metadata: jsonb("metadata").$type(),
+	...timestamps
+}, (table) => [primaryKey({ columns: [
+	table.tenantId,
+	table.projectId,
+	table.id
+] }), foreignKey({
+	columns: [
+		table.tenantId,
+		table.projectId,
+		table.conversationId
+	],
+	foreignColumns: [
+		conversations.tenantId,
+		conversations.projectId,
+		conversations.id
+	],
+	name: "messages_conversation_fk"
+}).onDelete("cascade")]);
+const taskRelations = pgTable("task_relations", {
+	...projectScoped,
+	parentTaskId: varchar("parent_task_id", { length: 256 }).notNull(),
+	childTaskId: varchar("child_task_id", { length: 256 }).notNull(),
+	relationType: varchar("relation_type", { length: 256 }).default("parent_child"),
+	...timestamps
+}, (table) => [
+	primaryKey({ columns: [
+		table.tenantId,
+		table.projectId,
+		table.id
+	] }),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.parentTaskId
+		],
+		foreignColumns: [
+			tasks.tenantId,
+			tasks.projectId,
+			tasks.id
+		],
+		name: "task_relations_parent_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.childTaskId
+		],
+		foreignColumns: [
+			tasks.tenantId,
+			tasks.projectId,
+			tasks.id
+		],
+		name: "task_relations_child_fk"
+	}).onDelete("cascade")
+]);
+const ledgerArtifacts = pgTable("ledger_artifacts", {
+	...projectScoped,
+	taskId: varchar("task_id", { length: 256 }).notNull(),
+	toolCallId: varchar("tool_call_id", { length: 256 }),
+	contextId: varchar("context_id", { length: 256 }).notNull(),
+	type: varchar("type", { length: 256 }).notNull().default("source"),
+	name: varchar("name", { length: 256 }),
+	description: text("description"),
+	parts: jsonb("parts").$type(),
+	metadata: jsonb("metadata").$type(),
+	summary: text("summary"),
+	mime: jsonb("mime").$type(),
+	visibility: varchar("visibility", { length: 256 }).default("context"),
+	allowedAgents: jsonb("allowed_agents").$type(),
+	derivedFrom: varchar("derived_from", { length: 256 }),
+	...timestamps
+}, (table) => [
+	primaryKey({ columns: [
+		table.tenantId,
+		table.projectId,
+		table.id,
+		table.taskId
+	] }),
+	index("ledger_artifacts_task_id_idx").on(table.taskId),
+	index("ledger_artifacts_tool_call_id_idx").on(table.toolCallId),
+	index("ledger_artifacts_context_id_idx").on(table.contextId),
+	unique("ledger_artifacts_task_context_name_unique").on(table.taskId, table.contextId, table.name),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.contextId
+		],
+		foreignColumns: [
+			conversations.tenantId,
+			conversations.projectId,
+			conversations.id
+		],
+		name: "ledger_artifacts_conversation_fk"
+	}).onDelete("cascade")
+]);
+const contextCache = pgTable("context_cache", {
+	...projectScoped,
+	conversationId: varchar("conversation_id", { length: 256 }).notNull(),
+	contextConfigId: varchar("context_config_id", { length: 256 }).notNull(),
+	contextVariableKey: varchar("context_variable_key", { length: 256 }).notNull(),
+	ref: jsonb("ref").$type(),
+	value: jsonb("value").$type().notNull(),
+	requestHash: varchar("request_hash", { length: 256 }),
+	fetchedAt: timestamp("fetched_at", { mode: "string" }).notNull().defaultNow(),
+	fetchSource: varchar("fetch_source", { length: 256 }),
+	...timestamps
+}, (table) => [
+	primaryKey({ columns: [
+		table.tenantId,
+		table.projectId,
+		table.id
+	] }),
+	index("context_cache_lookup_idx").on(table.conversationId, table.contextConfigId, table.contextVariableKey),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.conversationId
+		],
+		foreignColumns: [
+			conversations.tenantId,
+			conversations.projectId,
+			conversations.id
+		],
+		name: "context_cache_conversation_fk"
+	}).onDelete("cascade")
+]);
+/**
+* Execution of a suite of items from a dataset. Represents a batch run that
+* processes dataset items and creates conversations (basically a batch run of conversations). Tracks the execution
+* status and links to conversations created during the run via
+* datasetRunConversationRelations join table.
+*
+* When evaluators are specified, an evaluation job is automatically created after the run completes,
+* and the evaluationJobConfigId links to that job.
+*
+* Includes: datasetId (which dataset to run),
+* datasetRunConfigId (optional: if created from a config),
+* evaluationJobConfigId (optional: links to evaluation job created for this run), and timestamps
+*/
+const datasetRun = pgTable("dataset_run", {
+	...projectScoped,
+	datasetId: text("dataset_id").notNull(),
+	datasetRunConfigId: text("dataset_run_config_id"),
+	evaluationJobConfigId: text("evaluation_job_config_id"),
+	...timestamps
+}, (table) => [primaryKey({ columns: [
+	table.tenantId,
+	table.projectId,
+	table.id
+] })]);
+/**
+* Links conversations created during a dataset run execution. One-to-many
+* relationship where one datasetRun can create many conversations, but each
+* conversation belongs to exactly one datasetRun. Used to track which
+* conversations were generated from which dataset run.
+*
+* Includes: datasetRunId (composite FK to datasetRun), conversationId (composite FK to conversations),
+* datasetItemId (composite FK to datasetItem) to directly link conversations to their source dataset items,
+* unique constraint on (datasetRunId, conversationId) ensures one conversation per datasetRun,
+* and timestamps
+*/
+const datasetRunConversationRelations = pgTable("dataset_run_conversation_relations", {
+	...projectScoped,
+	datasetRunId: text("dataset_run_id").notNull(),
+	conversationId: text("conversation_id").notNull(),
+	datasetItemId: text("dataset_item_id").notNull(),
+	...timestamps
+}, (table) => [
+	primaryKey({ columns: [
+		table.tenantId,
+		table.projectId,
+		table.id
+	] }),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.datasetRunId
+		],
+		foreignColumns: [
+			datasetRun.tenantId,
+			datasetRun.projectId,
+			datasetRun.id
+		],
+		name: "dataset_run_conversation_relations_run_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.conversationId
+		],
+		foreignColumns: [
+			conversations.tenantId,
+			conversations.projectId,
+			conversations.id
+		],
+		name: "dataset_run_conversation_relations_conversation_fk"
+	}).onDelete("cascade"),
+	unique("dataset_run_conversation_relations_unique").on(table.datasetRunId, table.conversationId)
+]);
+/**
+* Record created when an evaluation job config or evaluation run config is triggered.
+* Represents a completed evaluation run. Links to the evaluationJobConfig (if created from a job)
+* or evaluationRunConfig (if created from a run config).
+* Results are stored in evaluationResult table.
+* one to many relationship with evaluationResult
+*
+* Includes: evaluationJobConfigId (optional: if created from a job),
+* evaluationRunConfigId (optional: if created from a run config),
+* and timestamps
+*/
+const evaluationRun = pgTable("evaluation_run", {
+	...projectScoped,
+	evaluationJobConfigId: text("evaluation_job_config_id"),
+	evaluationRunConfigId: text("evaluation_run_config_id"),
+	...timestamps
+}, (table) => [primaryKey({ columns: [
+	table.tenantId,
+	table.projectId,
+	table.id
+] })]);
+/**
+* Stores the result of evaluating a conversation with a specific evaluator.
+* Contains the evaluation output. Linked to an evaluation run.
+* Each result represents one evaluator's assessment of one conversation.
+*
+* Includes: conversationId (required), evaluatorId (required),
+* evaluationRunId (optional, links to evaluationRun),
+* output (evaluation result as MessageContent), and timestamps
+*/
+const evaluationResult = pgTable("evaluation_result", {
+	...projectScoped,
+	conversationId: text("conversation_id").notNull(),
+	evaluatorId: text("evaluator_id").notNull(),
+	evaluationRunId: text("evaluation_run_id"),
+	output: jsonb("output").$type(),
+	...timestamps
+}, (table) => [
+	primaryKey({ columns: [
+		table.tenantId,
+		table.projectId,
+		table.id
+	] }),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.conversationId
+		],
+		foreignColumns: [
+			conversations.tenantId,
+			conversations.projectId,
+			conversations.id
+		],
+		name: "evaluation_result_conversation_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.tenantId,
+			table.projectId,
+			table.evaluationRunId
+		],
+		foreignColumns: [
+			evaluationRun.tenantId,
+			evaluationRun.projectId,
+			evaluationRun.id
+		],
+		name: "evaluation_result_evaluation_run_fk"
+	}).onDelete("cascade")
+]);
+const conversationsRelations = relations(conversations, ({ many }) => ({ messages: many(messages) }));
+const messagesRelations = relations(messages, ({ one, many }) => ({
+	conversation: one(conversations, {
+		fields: [messages.conversationId],
+		references: [conversations.id]
+	}),
+	task: one(tasks, {
+		fields: [messages.taskId],
+		references: [tasks.id]
+	}),
+	parentMessage: one(messages, {
+		fields: [messages.parentMessageId],
+		references: [messages.id],
+		relationName: "parentChild"
+	}),
+	childMessages: many(messages, { relationName: "parentChild" })
+}));
+const tasksRelations = relations(tasks, ({ many }) => ({
+	messages: many(messages),
+	ledgerArtifacts: many(ledgerArtifacts),
+	parentRelations: many(taskRelations, { relationName: "childTask" }),
+	childRelations: many(taskRelations, { relationName: "parentTask" })
+}));
+const taskRelationsRelations = relations(taskRelations, ({ one }) => ({
+	parentTask: one(tasks, {
+		fields: [taskRelations.parentTaskId],
+		references: [tasks.id],
+		relationName: "parentTask"
+	}),
+	childTask: one(tasks, {
+		fields: [taskRelations.childTaskId],
+		references: [tasks.id],
+		relationName: "childTask"
+	})
+}));
+const ledgerArtifactsRelations = relations(ledgerArtifacts, ({ one }) => ({ task: one(tasks, {
+	fields: [ledgerArtifacts.taskId],
+	references: [tasks.id]
+}) }));
+
+//#endregion
+export { account, apiKeys, contextCache, conversations, conversationsRelations, datasetRun, datasetRunConversationRelations, deviceCode, evaluationResult, evaluationRun, invitation, ledgerArtifacts, ledgerArtifactsRelations, member, messages, messagesRelations, organization, projectMetadata, runtime_schema_exports, session, ssoProvider, taskRelations, taskRelationsRelations, tasks, tasksRelations, triggerInvocations, user, verification };

package/dist/db/runtime/test-runtime-client.d.ts

@@ -0,0 +1,27 @@
+import { AgentsRunDatabaseClient } from "./runtime-client.js";
+
+//#region src/db/runtime/test-runtime-client.d.ts
+
+/**
+ * Creates a test database client using an in-memory PostgreSQL database (PGlite)
+ * This provides real database operations for integration testing with perfect isolation
+ * Each call creates a fresh database with all migrations applied
+ */
+declare function createTestRuntimeDatabaseClient(drizzleDir: string): Promise<AgentsRunDatabaseClient>;
+declare function createTestRuntimeDatabaseClientNoMigrations(): AgentsRunDatabaseClient;
+/**
+ * Cleans up test database by removing all data but keeping schema
+ * Dynamically gets all tables from the public schema and truncates them
+ */
+declare function cleanupTestRuntimeDatabase(db: AgentsRunDatabaseClient): Promise<void>;
+/**
+ * Closes the test database and removes the file
+ */
+declare function closeTestRuntimeDatabase(db: AgentsRunDatabaseClient): Promise<void>;
+/**
+ * Creates a test organization in the database
+ * This is a helper for tests that need organization records before creating projects/agents
+ */
+declare function createTestOrganization(db: AgentsRunDatabaseClient, tenantId: string): Promise<void>;
+//#endregion
+export { cleanupTestRuntimeDatabase, closeTestRuntimeDatabase, createTestOrganization, createTestRuntimeDatabaseClient, createTestRuntimeDatabaseClientNoMigrations };

package/dist/db/{test-client.js → runtime/test-runtime-client.js}

@@ -1,23 +1,19 @@
-import { organization } from "../auth/auth-schema.js";
-import { projects, schema_exports } from "./schema.js";
+import { organization } from "../../auth/auth-schema.js";
+import { runtime_schema_exports } from "./runtime-schema.js";
 import { sql } from "drizzle-orm";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { PGlite } from "@electric-sql/pglite";
 import { drizzle } from "drizzle-orm/pglite";
 import { migrate } from "drizzle-orm/pglite/migrator";
 
-//#region src/db/test-client.ts
-const DIRNAME = dirname(fileURLToPath(import.meta.url));
+//#region src/db/runtime/test-runtime-client.ts
 /**
 * Creates a test database client using an in-memory PostgreSQL database (PGlite)
 * This provides real database operations for integration testing with perfect isolation
 * Each call creates a fresh database with all migrations applied
 */
-async function createTestDatabaseClient(drizzleDir) {
-	const db = drizzle(new PGlite(), { schema: schema_exports });
+async function createTestRuntimeDatabaseClient(drizzleDir) {
+	const db = drizzle(new PGlite(), { schema: runtime_schema_exports });
 	try {
-		if (!drizzleDir) drizzleDir = join(DIRNAME, "../../drizzle");
 		await migrate(db, { migrationsFolder: drizzleDir });
 	} catch (error) {
 		console.error("Failed to initialize test database schema:", error);
@@ -25,11 +21,14 @@ async function createTestDatabaseClient(drizzleDir) {
 	}
 	return db;
 }
+function createTestRuntimeDatabaseClientNoMigrations() {
+	return drizzle(new PGlite(), { schema: runtime_schema_exports });
+}
 /**
 * Cleans up test database by removing all data but keeping schema
 * Dynamically gets all tables from the public schema and truncates them
 */
-async function cleanupTestDatabase(db) {
+async function cleanupTestRuntimeDatabase(db) {
 	try {
 		const tables = (await db.execute(sql.raw(`
       SELECT tablename 
@@ -46,7 +45,7 @@ async function cleanupTestDatabase(db) {
 /**
 * Closes the test database and removes the file
 */
-async function closeTestDatabase(db) {
+async function closeTestRuntimeDatabase(db) {
 	try {
 		if ("close" in db && typeof db.close === "function") db.close();
 	} catch (error) {
@@ -67,19 +66,6 @@ async function createTestOrganization(db, tenantId) {
 		metadata: null
 	}).onConflictDoNothing();
 }
-/**
-* Creates a test project in the database
-* Ensures the organization exists first
-*/
-async function createTestProject(db, tenantId, projectId = "default") {
-	await createTestOrganization(db, tenantId);
-	await db.insert(projects).values({
-		tenantId,
-		id: projectId,
-		name: `Test Project ${projectId}`,
-		description: `Test project for ${projectId}`
-	}).onConflictDoNothing();
-}
 
 //#endregion
-export { cleanupTestDatabase, closeTestDatabase, createTestDatabaseClient, createTestOrganization, createTestProject };
+export { cleanupTestRuntimeDatabase, closeTestRuntimeDatabase, createTestOrganization, createTestRuntimeDatabaseClient, createTestRuntimeDatabaseClientNoMigrations };

package/dist/dolt/branch.d.ts

@@ -0,0 +1,62 @@
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
+
+//#region src/dolt/branch.d.ts
+type branchScopes = {
+  tenantId: string;
+  projectId: string;
+  branchName: string;
+};
+/**
+ * Create a new branch
+ */
+declare const doltBranch: (db: AgentsManageDatabaseClient) => (params: {
+  name: string;
+  startPoint?: string;
+}) => Promise<void>;
+/**
+ * Delete a branch
+ */
+declare const doltDeleteBranch: (db: AgentsManageDatabaseClient) => (params: {
+  name: string;
+  force?: boolean;
+}) => Promise<void>;
+/**
+ * Rename a branch
+ */
+declare const doltRenameBranch: (db: AgentsManageDatabaseClient) => (params: {
+  oldName: string;
+  newName: string;
+}) => Promise<void>;
+/**
+ * List all branches
+ */
+declare const doltListBranches: (db: AgentsManageDatabaseClient) => () => Promise<{
+  name: string;
+  hash: string;
+  latest_commit_date: Date;
+}[]>;
+/**
+ * Check if a branch exists
+ */
+declare const doltBranchExists: (db: AgentsManageDatabaseClient) => (params: {
+  name: string;
+}) => Promise<boolean>;
+/**
+ * Checkout a branch or create and checkout a new branch
+ */
+declare const doltCheckout: (db: AgentsManageDatabaseClient) => (params: {
+  branch: string;
+  create?: boolean;
+}) => Promise<void>;
+/**
+ * Get the currently active branch
+ */
+declare const doltActiveBranch: (db: AgentsManageDatabaseClient) => () => Promise<string>;
+declare const doltGetBranchNamespace: (scopes: branchScopes) => () => string;
+/**
+ * Create a branch if it doesn't exist, handling race conditions gracefully.
+ * If multiple concurrent requests try to create the same branch, only one will succeed.
+ */
+declare const ensureBranchExists: (db: AgentsManageDatabaseClient, branchName: string) => Promise<void>;
+//#endregion
+export { branchScopes, doltActiveBranch, doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches, doltRenameBranch, ensureBranchExists };