@inkeep/agents-api 0.0.1

package/dist/domains/run/data/agent.js

@@ -0,0 +1,67 @@
+import { getAgentFromProject, getSubAgentFromProject } from "../utils/project.js";
+import { createTaskHandler, createTaskHandlerConfig } from "../agents/generateTaskHandler.js";
+
+//#region src/domains/run/data/agent.ts
+async function hydrateAgent({ dbAgent, executionContext, baseUrl }) {
+	const { tenantId, projectId, agentId, project, apiKey } = executionContext;
+	try {
+		if (!dbAgent.defaultSubAgentId) throw new Error(`Agent ${dbAgent.id} does not have a default agent configured`);
+		const subAgentId = dbAgent.defaultSubAgentId;
+		if (!getSubAgentFromProject({
+			project,
+			agentId,
+			subAgentId
+		})) throw new Error(`Default agent ${dbAgent.defaultSubAgentId} not found for agent ${dbAgent.id}`);
+		const taskHandler = createTaskHandler(await createTaskHandlerConfig({
+			executionContext,
+			subAgentId: dbAgent.defaultSubAgentId,
+			baseUrl,
+			apiKey
+		}));
+		const agentCard = {
+			name: dbAgent.name,
+			description: dbAgent.description || `Agent: ${dbAgent.name}`,
+			url: baseUrl ? `${baseUrl}/a2a` : "",
+			version: "1.0.0",
+			capabilities: {
+				streaming: true,
+				pushNotifications: false,
+				stateTransitionHistory: false
+			},
+			defaultInputModes: ["text", "text/plain"],
+			defaultOutputModes: ["text", "text/plain"],
+			skills: [],
+			...baseUrl && { provider: {
+				organization: "Inkeep",
+				url: baseUrl
+			} }
+		};
+		return {
+			subAgentId: dbAgent.id,
+			tenantId,
+			projectId,
+			agentId: dbAgent.id,
+			agentCard,
+			taskHandler
+		};
+	} catch (error) {
+		console.error(`❌ Failed to hydrate agent ${dbAgent.id}:`, error);
+		throw error;
+	}
+}
+async function getRegisteredAgent(executionContext) {
+	const { project, agentId, baseUrl } = executionContext;
+	const dbAgent = getAgentFromProject({
+		project,
+		agentId
+	});
+	if (!dbAgent) return null;
+	return hydrateAgent({
+		dbAgent,
+		executionContext,
+		baseUrl: `${baseUrl}/run/agents`
+	});
+}
+
+//#endregion
+export { getRegisteredAgent };

package/dist/domains/run/data/agents.d.ts

@@ -0,0 +1,34 @@
+import { AgentCard as AgentCard$1, RegisteredAgent } from "../a2a/types.js";
+import { SandboxConfig } from "../types/executionContext.js";
+import { CredentialStoreRegistry, FullExecutionContext, SubAgentSelect } from "@inkeep/agents-core";
+
+//#region src/domains/run/data/agents.d.ts
+
+/**
+ * Create an AgentCard from database agent data
+ * Reusable function that standardizes agent card creation across the codebase
+ * Used for external discovery via /.well-known/agent.json endpoint
+ */
+declare function createAgentCard({
+  dbAgent,
+  baseUrl
+}: {
+  dbAgent: SubAgentSelect;
+  baseUrl: string;
+}): AgentCard$1;
+/**
+ * Generate an enhanced description that includes transfer and delegation information
+ * Used in generateTaskHandler to help agents understand what other agents can do
+ *
+ * @param baseDescription - The base description of the agent
+ * @param internalRelations - Pre-computed internal relations
+ * @param externalRelations - Pre-computed external relations
+ */
+declare function generateDescriptionWithRelationData(baseDescription: string, internalRelations: any[], externalRelations: any[], teamRelations: any[]): string;
+declare function getRegisteredAgent(params: {
+  executionContext: FullExecutionContext;
+  credentialStoreRegistry?: CredentialStoreRegistry;
+  sandboxConfig?: SandboxConfig;
+}): Promise<RegisteredAgent | null>;
+//#endregion
+export { createAgentCard, generateDescriptionWithRelationData, getRegisteredAgent };

package/dist/domains/run/data/agents.js

@@ -0,0 +1,131 @@
+import { getLogger } from "../../../logger.js";
+import { getSubAgentFromProject } from "../utils/project.js";
+import { createTaskHandler, createTaskHandlerConfig } from "../agents/generateTaskHandler.js";
+
+//#region src/domains/run/data/agents.ts
+const logger = getLogger("agents");
+/**
+* Create an AgentCard from database agent data
+* Reusable function that standardizes agent card creation across the codebase
+* Used for external discovery via /.well-known/agent.json endpoint
+*/
+function createAgentCard({ dbAgent, baseUrl }) {
+	const description = dbAgent.description || "AI Agent";
+	return {
+		name: dbAgent.name,
+		description,
+		url: baseUrl ? `${baseUrl}/a2a` : "",
+		version: "1.0.0",
+		capabilities: {
+			streaming: true,
+			pushNotifications: false,
+			stateTransitionHistory: false
+		},
+		defaultInputModes: ["text", "text/plain"],
+		defaultOutputModes: ["text", "text/plain"],
+		skills: [],
+		...baseUrl && { provider: {
+			organization: "Inkeep",
+			url: baseUrl
+		} }
+	};
+}
+/**
+* Generate an enhanced description that includes transfer and delegation information
+* Used in generateTaskHandler to help agents understand what other agents can do
+*
+* @param baseDescription - The base description of the agent
+* @param internalRelations - Pre-computed internal relations
+* @param externalRelations - Pre-computed external relations
+*/
+function generateDescriptionWithRelationData(baseDescription, internalRelations, externalRelations, teamRelations) {
+	const transfers = [...internalRelations.filter((rel) => rel.relationType === "transfer")];
+	const delegates = [
+		...internalRelations.filter((rel) => rel.relationType === "delegate"),
+		...externalRelations.map((data) => data.externalAgent),
+		...teamRelations.map((data) => data.targetAgent)
+	];
+	if (transfers.length === 0 && delegates.length === 0) return baseDescription;
+	let enhancedDescription = baseDescription;
+	if (transfers.length > 0) {
+		const transferList = transfers.map((rel) => {
+			return `- ${rel.externalAgent?.name || rel.name}: ${rel.externalAgent?.description || rel.description || ""}`;
+		}).join("\n");
+		enhancedDescription += `\n\nCan transfer to:\n${transferList}`;
+	}
+	if (delegates.length > 0) {
+		const delegateList = delegates.map((rel) => {
+			return `- ${rel.name}: ${rel.description || ""}`;
+		}).join("\n");
+		enhancedDescription += `\n\nCan delegate to:\n${delegateList}`;
+	}
+	return enhancedDescription;
+}
+/**
+* Create a RegisteredAgent from database agent data
+* Hydrates agent directly from database schema using types from schema.ts
+*/
+async function hydrateAgent({ dbAgent, executionContext, baseUrl, apiKey, credentialStoreRegistry, sandboxConfig }) {
+	try {
+		const taskHandlerConfig = await createTaskHandlerConfig({
+			executionContext,
+			subAgentId: dbAgent.id,
+			baseUrl,
+			apiKey,
+			sandboxConfig
+		});
+		const { tenantId, projectId, agentId } = executionContext;
+		const taskHandler = createTaskHandler(taskHandlerConfig, credentialStoreRegistry);
+		const agentCard = createAgentCard({
+			dbAgent: {
+				...dbAgent,
+				tenantId,
+				projectId,
+				agentId
+			},
+			baseUrl
+		});
+		return {
+			subAgentId: dbAgent.id,
+			tenantId,
+			projectId,
+			agentId,
+			agentCard,
+			taskHandler
+		};
+	} catch (error) {
+		console.error(`❌ Failed to hydrate agent ${dbAgent.id}:`, error);
+		throw error;
+	}
+}
+async function getRegisteredAgent(params) {
+	const { executionContext, credentialStoreRegistry, sandboxConfig } = params;
+	const { agentId, subAgentId, baseUrl, apiKey, project } = executionContext;
+	const dbAgent = getSubAgentFromProject({
+		project,
+		agentId,
+		subAgentId
+	});
+	if (!dbAgent) {
+		logger.warn({
+			agentId,
+			subAgentId
+		}, "Could not find sub-agent in project");
+		return null;
+	}
+	logger.info({
+		agentId,
+		subAgentId: dbAgent.id
+	}, "Found sub-agent from project definition");
+	return hydrateAgent({
+		dbAgent,
+		executionContext,
+		baseUrl: `${baseUrl}/run/agents`,
+		credentialStoreRegistry,
+		apiKey,
+		sandboxConfig
+	});
+}
+
+//#endregion
+export { createAgentCard, generateDescriptionWithRelationData, getRegisteredAgent };

package/dist/domains/run/data/conversations.d.ts

@@ -0,0 +1,129 @@
+import { AgentConversationHistoryConfig, Artifact, ConversationHistoryConfig, ConversationScopeOptions, ResolvedRef } from "@inkeep/agents-core";
+
+//#region src/domains/run/data/conversations.d.ts
+declare const compressionLocks: Map<string, Promise<any>>;
+/**
+ * Creates default conversation history configuration
+ * @param mode - The conversation history mode ('full' | 'scoped' | 'none')
+ * @returns Default AgentConversationHistoryConfig
+ */
+declare function createDefaultConversationHistoryConfig(mode?: 'full' | 'scoped' | 'none'): AgentConversationHistoryConfig;
+/**
+ * Saves the result of an A2A client sendMessage call as a conversation message
+ * @param response - The response from a2aClient.sendMessage()
+ * @param params - Parameters for saving the message
+ * @returns The saved message or null if no text content was found
+ */
+declare function saveA2AMessageResponse(response: any,
+// SendMessageResponse type
+params: {
+  tenantId: string;
+  projectId: string;
+  conversationId: string;
+  messageType: 'a2a-response' | 'a2a-request';
+  visibility: 'internal' | 'external' | 'user-facing';
+  fromSubAgentId?: string;
+  toSubAgentId?: string;
+  fromExternalAgentId?: string;
+  toExternalAgentId?: string;
+  a2aTaskId?: string;
+  a2aSessionId?: string;
+  metadata?: Record<string, unknown>;
+}): Promise<any | null>;
+/**
+ * Applies filtering based on agent, task, or both criteria
+ * Returns the filtered messages array
+ */
+declare function getScopedHistory({
+  tenantId,
+  projectId,
+  conversationId,
+  filters,
+  options
+}: {
+  tenantId: string;
+  projectId: string;
+  conversationId: string;
+  filters?: ConversationScopeOptions;
+  options?: ConversationHistoryConfig;
+}): Promise<any[]>;
+/**
+ * Get user-facing conversation history (for client display)
+ */
+declare function getUserFacingHistory(tenantId: string, projectId: string, conversationId: string, limit?: 50): Promise<any[]>;
+/**
+ * Get full conversation context (for agent processing)
+ */
+declare function getFullConversationContext(tenantId: string, projectId: string, conversationId: string, maxTokens?: number): Promise<any[]>;
+/**
+ * Get formatted conversation history for a2a
+ */
+declare function getFormattedConversationHistory({
+  tenantId,
+  projectId,
+  conversationId,
+  currentMessage,
+  options,
+  filters,
+  sessionId,
+  summarizerModel
+}: {
+  tenantId: string;
+  projectId: string;
+  conversationId: string;
+  currentMessage?: string;
+  options?: ConversationHistoryConfig;
+  filters?: ConversationScopeOptions;
+  sessionId?: string;
+  summarizerModel?: any;
+}): Promise<string>;
+/**
+ * Modern conversation history retrieval with compression support
+ * Replaces getFormattedConversationHistory with built-in compression when needed
+ */
+declare function getConversationHistoryWithCompression({
+  tenantId,
+  projectId,
+  conversationId,
+  currentMessage,
+  options,
+  filters,
+  summarizerModel,
+  streamRequestId,
+  fullContextSize
+}: {
+  tenantId: string;
+  projectId: string;
+  conversationId: string;
+  currentMessage?: string;
+  options?: ConversationHistoryConfig;
+  filters?: ConversationScopeOptions;
+  summarizerModel?: any;
+  streamRequestId?: string;
+  fullContextSize?: number;
+}): Promise<string>;
+/**
+ * Apply conversation compression using the BaseCompressor infrastructure
+ */
+declare function compressConversationIfNeeded(messages: any[], params: {
+  conversationId: string;
+  tenantId: string;
+  projectId: string;
+  summarizerModel: any;
+  streamRequestId?: string;
+  fullContextSize?: number;
+}): Promise<any[]>;
+/**
+ * Get artifacts that are within the scope of the conversation history
+ * Only returns artifacts from messages that are actually visible to the LLM
+ * Uses the same scoping logic as getFormattedConversationHistory
+ */
+declare function getConversationScopedArtifacts(params: {
+  tenantId: string;
+  projectId: string;
+  conversationId: string;
+  historyConfig: AgentConversationHistoryConfig;
+  ref: ResolvedRef;
+}): Promise<Artifact[]>;
+//#endregion
+export { compressConversationIfNeeded, compressionLocks, createDefaultConversationHistoryConfig, getConversationHistoryWithCompression, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };