@inkeep/agents-run-api 0.0.0-dev-20260113172432 → 0.0.0-dev-20260115183047

package/dist/context/index.js

@@ -0,0 +1,7 @@
+import { ContextCache } from "./contextCache.js";
+import { ContextResolver } from "./ContextResolver.js";
+import { HTTP_REQUEST_PARTS, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper } from "./validation.js";
+import { ContextFetcher, MissingRequiredVariableError } from "./ContextFetcher.js";
+import { determineContextTrigger, handleContextConfigChange, handleContextResolution } from "./context.js";
+
+export { ContextCache, ContextFetcher, ContextResolver, HTTP_REQUEST_PARTS, MissingRequiredVariableError, contextValidationMiddleware, determineContextTrigger, getCachedValidator, handleContextConfigChange, handleContextResolution, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/context/validation.d.ts

@@ -0,0 +1,39 @@
+import { CredentialStoreRegistry, FullExecutionContext } from "@inkeep/agents-core";
+import { Context, Next } from "hono";
+import { ValidateFunction } from "ajv";
+
+//#region src/context/validation.d.ts
+declare const HTTP_REQUEST_PARTS: readonly ["headers"];
+type HttpRequestPart = (typeof HTTP_REQUEST_PARTS)[number];
+interface ContextValidationError {
+  field: string;
+  message: string;
+  value?: unknown;
+}
+interface ContextValidationResult {
+  valid: boolean;
+  errors: ContextValidationError[];
+  validatedContext?: Record<string, unknown> | ParsedHttpRequest;
+}
+interface ParsedHttpRequest {
+  headers?: Record<string, string>;
+}
+declare function isValidHttpRequest(obj: any): obj is ParsedHttpRequest;
+declare function getCachedValidator(schema: Record<string, unknown>): ValidateFunction;
+declare function validationHelper(jsonSchema: Record<string, unknown>): ValidateFunction<unknown>;
+declare function validateAgainstJsonSchema(jsonSchema: Record<string, unknown>, context: unknown): boolean;
+declare function validateHttpRequestHeaders(headersSchema: any, httpRequest: ParsedHttpRequest): Promise<ContextValidationResult>;
+declare function validateHeaders({
+  executionContext,
+  conversationId,
+  parsedRequest,
+  credentialStores
+}: {
+  executionContext: FullExecutionContext;
+  conversationId: string;
+  parsedRequest: ParsedHttpRequest;
+  credentialStores?: CredentialStoreRegistry;
+}): Promise<ContextValidationResult>;
+declare function contextValidationMiddleware(c: Context, next: Next): Promise<void>;
+//#endregion
+export { ContextValidationError, ContextValidationResult, HTTP_REQUEST_PARTS, HttpRequestPart, ParsedHttpRequest, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/context/validation.js

@@ -0,0 +1,255 @@
+import { ContextResolver } from "./ContextResolver.js";
+import { createApiError, getLogger } from "@inkeep/agents-core";
+import Ajv from "ajv";
+
+//#region src/context/validation.ts
+const logger = getLogger("context-validation");
+const ajv = new Ajv({
+	allErrors: true,
+	strict: false
+});
+const HTTP_REQUEST_PARTS = ["headers"];
+const MAX_SCHEMA_CACHE_SIZE = 1e3;
+const schemaCache = /* @__PURE__ */ new Map();
+function isValidHttpRequest(obj) {
+	return obj != null && typeof obj === "object" && !Array.isArray(obj) && "headers" in obj;
+}
+function getCachedValidator(schema) {
+	const key = JSON.stringify(schema);
+	if (schemaCache.has(key)) {
+		const validator$1 = schemaCache.get(key);
+		if (!validator$1) throw new Error("Unexpected: validator not found in cache after has() check");
+		schemaCache.delete(key);
+		schemaCache.set(key, validator$1);
+		return validator$1;
+	}
+	if (schemaCache.size >= MAX_SCHEMA_CACHE_SIZE) {
+		const firstKey = schemaCache.keys().next().value;
+		if (firstKey) schemaCache.delete(firstKey);
+	}
+	const permissiveSchema = makeSchemaPermissive(schema);
+	const validator = ajv.compile(permissiveSchema);
+	schemaCache.set(key, validator);
+	return validator;
+}
+function makeSchemaPermissive(schema) {
+	if (!schema || typeof schema !== "object") return schema;
+	const permissiveSchema = { ...schema };
+	if (permissiveSchema.type === "object") {
+		permissiveSchema.additionalProperties = true;
+		if (permissiveSchema.properties && typeof permissiveSchema.properties === "object") {
+			const newProperties = {};
+			for (const [key, value] of Object.entries(permissiveSchema.properties)) newProperties[key] = makeSchemaPermissive(value);
+			permissiveSchema.properties = newProperties;
+		}
+	}
+	if (permissiveSchema.type === "array" && permissiveSchema.items) permissiveSchema.items = makeSchemaPermissive(permissiveSchema.items);
+	if (permissiveSchema.oneOf) permissiveSchema.oneOf = permissiveSchema.oneOf.map(makeSchemaPermissive);
+	if (permissiveSchema.anyOf) permissiveSchema.anyOf = permissiveSchema.anyOf.map(makeSchemaPermissive);
+	if (permissiveSchema.allOf) permissiveSchema.allOf = permissiveSchema.allOf.map(makeSchemaPermissive);
+	return permissiveSchema;
+}
+function validationHelper(jsonSchema) {
+	return getCachedValidator(jsonSchema);
+}
+function validateAgainstJsonSchema(jsonSchema, context) {
+	return validationHelper(jsonSchema)(context);
+}
+function filterByJsonSchema(data, schema) {
+	if (!schema || data === null || data === void 0) return data;
+	if (schema.type === "object" && schema.properties && typeof data === "object" && !Array.isArray(data)) {
+		const filtered = {};
+		for (const [key, propSchema] of Object.entries(schema.properties)) if (key in data) filtered[key] = filterByJsonSchema(data[key], propSchema);
+		return filtered;
+	}
+	if (schema.type === "array" && schema.items && Array.isArray(data)) return data.map((item) => filterByJsonSchema(item, schema.items));
+	if (schema.anyOf && Array.isArray(schema.anyOf)) {
+		for (const subSchema of schema.anyOf) if (subSchema.type && typeof data === subSchema.type) return filterByJsonSchema(data, subSchema);
+		return filterByJsonSchema(data, schema.anyOf[0]);
+	}
+	return data;
+}
+function filterContextToSchemaKeys(validatedContext, headersSchema) {
+	if (!headersSchema || !validatedContext) return validatedContext;
+	const filteredHeaders = filterByJsonSchema(validatedContext, headersSchema);
+	if (filteredHeaders !== null && filteredHeaders !== void 0) {
+		if (typeof filteredHeaders === "object" && Object.keys(filteredHeaders).length > 0) return filteredHeaders;
+		if (typeof filteredHeaders !== "object") return filteredHeaders;
+	}
+	return {};
+}
+async function validateHttpRequestHeaders(headersSchema, httpRequest) {
+	const errors = [];
+	let validatedContext = {};
+	if (!isValidHttpRequest(httpRequest)) return {
+		valid: false,
+		errors: [{
+			field: "httpRequest",
+			message: "Invalid HTTP request format - must contain headers"
+		}]
+	};
+	try {
+		if (headersSchema && httpRequest.headers !== void 0) try {
+			const validate = validationHelper(headersSchema);
+			if (validate(httpRequest.headers)) validatedContext = httpRequest.headers;
+			else if (validate.errors) for (const error of validate.errors) errors.push({
+				field: `headers.${error.instancePath || "root"}`,
+				message: `headers ${error.message}`,
+				value: error.data
+			});
+		} catch (validationError) {
+			errors.push({
+				field: "headers",
+				message: `Failed to validate headers: ${validationError instanceof Error ? validationError.message : "Unknown error"}`
+			});
+		}
+		const filteredContext = errors.length === 0 ? filterContextToSchemaKeys(validatedContext, headersSchema) : void 0;
+		return {
+			valid: errors.length === 0,
+			errors,
+			validatedContext: filteredContext
+		};
+	} catch (error) {
+		logger.error({ error: error instanceof Error ? error.message : "Unknown error" }, "Failed to validate headers schema");
+		return {
+			valid: false,
+			errors: [{
+				field: "schema",
+				message: "Failed to validate headers schema"
+			}]
+		};
+	}
+}
+async function fetchExistingHeaders({ executionContext, contextConfig, conversationId, credentialStores }) {
+	const headers$1 = await new ContextResolver(executionContext, credentialStores).resolveHeaders(conversationId, contextConfig.id);
+	if (Object.keys(headers$1).length > 0) return {
+		valid: true,
+		errors: [],
+		validatedContext: headers$1
+	};
+	throw new Error("No headers found in cache. Please provide headers in request.");
+}
+async function validateHeaders({ executionContext, conversationId, parsedRequest, credentialStores }) {
+	try {
+		const { tenantId, projectId, agentId, project } = executionContext;
+		logger.info({
+			tenantId,
+			projectId,
+			agentId
+		}, "Validating headers");
+		const contextConfig = project.agents[agentId].contextConfig;
+		logger.info({ contextConfig }, "Context config found");
+		if (!contextConfig) {
+			logger.info({ agentId }, "No context config found for agent, skipping validation");
+			return {
+				valid: true,
+				errors: [],
+				validatedContext: parsedRequest
+			};
+		}
+		if (!contextConfig.headersSchema) {
+			logger.debug({ contextConfigId: contextConfig.id }, "No headers schema defined, accepting any context");
+			return {
+				valid: true,
+				errors: [],
+				validatedContext: parsedRequest
+			};
+		}
+		try {
+			const schema = contextConfig.headersSchema;
+			logger.debug({ contextConfigId: contextConfig.id }, "Using headers schema validation");
+			const validationResult = await validateHttpRequestHeaders(schema, parsedRequest);
+			if (validationResult.valid) return validationResult;
+			try {
+				return await fetchExistingHeaders({
+					executionContext,
+					contextConfig,
+					conversationId,
+					credentialStores
+				});
+			} catch (_error) {
+				validationResult.errors.push({
+					field: "headers",
+					message: "Failed to fetch headers from cache"
+				});
+				return validationResult;
+			}
+		} catch (error) {
+			logger.error({
+				contextConfigId: contextConfig.id,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to compile or validate schema");
+			return {
+				valid: false,
+				errors: [{
+					field: "schema",
+					message: "Invalid schema definition or validation error"
+				}]
+			};
+		}
+	} catch (error) {
+		logger.error({
+			tenantId: executionContext.tenantId,
+			agentId: executionContext.agentId,
+			error: error instanceof Error ? error.message : "Unknown error"
+		}, "Failed to validate headers");
+		return {
+			valid: false,
+			errors: [{
+				field: "validation",
+				message: "Context validation failed due to internal error"
+			}]
+		};
+	}
+}
+async function contextValidationMiddleware(c, next) {
+	try {
+		const executionContext = c.get("executionContext");
+		let { tenantId, projectId, agentId, ref } = executionContext;
+		if (!tenantId || !projectId || !agentId) {
+			tenantId = c.req.param("tenantId");
+			projectId = c.req.param("projectId");
+			agentId = c.req.param("agentId");
+		}
+		if (!tenantId || !projectId || !agentId) return next();
+		const conversationId = (c.get("requestBody") || {}).conversationId || "";
+		const headers$1 = {};
+		c.req.raw.headers.forEach((value, key) => {
+			headers$1[key.toLowerCase()] = value;
+		});
+		const credentialStores = c.get("credentialStores");
+		const validationResult = await validateHeaders({
+			executionContext,
+			conversationId,
+			parsedRequest: { headers: headers$1 },
+			credentialStores
+		});
+		if (!validationResult.valid) {
+			logger.warn({
+				tenantId,
+				agentId,
+				errors: validationResult.errors
+			}, "Headers validation failed");
+			throw createApiError({
+				code: "bad_request",
+				message: `Invalid headers: ${validationResult.errors.map((e) => `${e.field}: ${e.message}`).join(", ")}`
+			});
+		}
+		c.set("validatedContext", validationResult.validatedContext);
+		logger.debug({
+			tenantId,
+			agentId,
+			contextKeys: Object.keys(validationResult.validatedContext || {})
+		}, "Request context validation successful");
+		return next();
+	} catch (error) {
+		logger.error({ error: error instanceof Error ? error.message : "Unknown error" }, "Context validation middleware error");
+		throw createApiError({
+			code: "internal_server_error",
+			message: "Context validation failed"
+		});
+	}
+}
+
+//#endregion
+export { HTTP_REQUEST_PARTS, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/create-app.d.ts

@@ -1,9 +1,9 @@
 import { SandboxConfig } from "./types/execution-context.js";
 import { CredentialStoreRegistry, ServerConfig } from "@inkeep/agents-core";
 import { Hono } from "hono";
-import * as hono_types3 from "hono/types";
+import * as hono_types0 from "hono/types";
 
 //#region src/create-app.d.ts
-declare function createExecutionHono(serverConfig: ServerConfig, credentialStores: CredentialStoreRegistry, sandboxConfig?: SandboxConfig): Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+declare function createExecutionHono(serverConfig: ServerConfig, credentialStores: CredentialStoreRegistry, sandboxConfig?: SandboxConfig): Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
 //#endregion
 export { createExecutionHono };

package/dist/create-app.js

@@ -1,6 +1,7 @@
-import { getLogger } from "./logger.js";
+import { getLogger as getLogger$1 } from "./logger.js";
 import { flushBatchProcessor } from "./instrumentation.js";
 import { apiKeyAuth } from "./middleware/api-key-auth.js";
+import { projectConfigMiddleware } from "./middleware/projectConfig.js";
 import { setupOpenAPIRoutes } from "./openapi.js";
 import agents_default from "./routes/agents.js";
 import chat_default from "./routes/chat.js";
@@ -16,7 +17,7 @@ import { HTTPException } from "hono/http-exception";
 import { requestId } from "hono/request-id";
 
 //#region src/create-app.ts
-const logger = getLogger("agents-run-api");
+const logger = getLogger$1("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
 	const app = new OpenAPIHono();
 	app.use("*", otel());
@@ -125,6 +126,10 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
 	app.use("/agents/*", apiKeyAuth());
 	app.use("/v1/*", apiKeyAuth());
 	app.use("/api/*", apiKeyAuth());
+	app.use("/tenants/*", projectConfigMiddleware);
+	app.use("/agents/*", projectConfigMiddleware);
+	app.use("/v1/*", projectConfigMiddleware);
+	app.use("/api/*", projectConfigMiddleware);
 	app.use("*", async (c, next) => {
 		const executionContext = c.get("executionContext");
 		if (!executionContext) {

package/dist/data/agent.d.ts

@@ -1,7 +1,7 @@
 import { RegisteredAgent } from "../a2a/types.js";
-import { ExecutionContext } from "@inkeep/agents-core";
+import { FullExecutionContext } from "@inkeep/agents-core";
 
 //#region src/data/agent.d.ts
-declare function getRegisteredAgent(executionContext: ExecutionContext): Promise<RegisteredAgent | null>;
+declare function getRegisteredAgent(executionContext: FullExecutionContext): Promise<RegisteredAgent | null>;
 //#endregion
 export { getRegisteredAgent };

package/dist/data/agent.js

@@ -1,23 +1,19 @@
-import dbClient_default from "./db/dbClient.js";
+import { getAgentFromProject, getSubAgentFromProject } from "../utils/project.js";
 import { createTaskHandler, createTaskHandlerConfig } from "../agents/generateTaskHandler.js";
-import { getAgentById, getSubAgentById } from "@inkeep/agents-core";
 
 //#region src/data/agent.ts
-async function hydrateAgent({ dbAgent, baseUrl, apiKey }) {
+async function hydrateAgent({ dbAgent, executionContext, baseUrl }) {
+	const { tenantId, projectId, agentId, project, resolvedRef, apiKey } = executionContext;
 	try {
 		if (!dbAgent.defaultSubAgentId) throw new Error(`Agent ${dbAgent.id} does not have a default agent configured`);
-		if (!await getSubAgentById(dbClient_default)({
-			scopes: {
-				tenantId: dbAgent.tenantId,
-				projectId: dbAgent.projectId,
-				agentId: dbAgent.id
-			},
-			subAgentId: dbAgent.defaultSubAgentId
+		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({
-			tenantId: dbAgent.tenantId,
-			projectId: dbAgent.projectId,
-			agentId: dbAgent.id,
+			executionContext,
 			subAgentId: dbAgent.defaultSubAgentId,
 			baseUrl,
 			apiKey
@@ -42,8 +38,8 @@ async function hydrateAgent({ dbAgent, baseUrl, apiKey }) {
 		};
 		return {
 			subAgentId: dbAgent.id,
-			tenantId: dbAgent.tenantId,
-			projectId: dbAgent.projectId,
+			tenantId,
+			projectId,
 			agentId: dbAgent.id,
 			agentCard,
 			taskHandler
@@ -54,17 +50,16 @@ async function hydrateAgent({ dbAgent, baseUrl, apiKey }) {
 	}
 }
 async function getRegisteredAgent(executionContext) {
-	const { tenantId, projectId, agentId, baseUrl, apiKey } = executionContext;
-	const dbAgent = await getAgentById(dbClient_default)({ scopes: {
-		tenantId,
-		projectId,
+	const { project, agentId, baseUrl } = executionContext;
+	const dbAgent = getAgentFromProject({
+		project,
 		agentId
-	} });
+	});
 	if (!dbAgent) return null;
 	return hydrateAgent({
 		dbAgent,
-		baseUrl: `${baseUrl}/agents`,
-		apiKey
+		executionContext,
+		baseUrl: `${baseUrl}/agents`
 	});
 }
 

package/dist/data/agents.d.ts

@@ -1,6 +1,6 @@
 import { AgentCard as AgentCard$1, RegisteredAgent } from "../a2a/types.js";
 import { SandboxConfig } from "../types/execution-context.js";
-import { CredentialStoreRegistry, ExecutionContext, SubAgentSelect } from "@inkeep/agents-core";
+import { CredentialStoreRegistry, FullExecutionContext, SubAgentSelect } from "@inkeep/agents-core";
 
 //#region src/data/agents.d.ts
 
@@ -26,7 +26,7 @@ declare function createAgentCard({
  */
 declare function generateDescriptionWithRelationData(baseDescription: string, internalRelations: any[], externalRelations: any[], teamRelations: any[]): string;
 declare function getRegisteredAgent(params: {
-  executionContext: ExecutionContext;
+  executionContext: FullExecutionContext;
   credentialStoreRegistry?: CredentialStoreRegistry;
   sandboxConfig?: SandboxConfig;
 }): Promise<RegisteredAgent | null>;

package/dist/data/agents.js

@@ -1,8 +1,6 @@
 import { getLogger } from "../logger.js";
-import dbClient_default from "./db/dbClient.js";
-import { getUserIdFromContext } from "../types/execution-context.js";
+import { getSubAgentFromProject } from "../utils/project.js";
 import { createTaskHandler, createTaskHandlerConfig } from "../agents/generateTaskHandler.js";
-import { getAgentWithDefaultSubAgent, getSubAgentById } from "@inkeep/agents-core";
 
 //#region src/data/agents.ts
 const logger = getLogger("agents");
@@ -67,26 +65,30 @@ function generateDescriptionWithRelationData(baseDescription, internalRelations,
 * Create a RegisteredAgent from database agent data
 * Hydrates agent directly from database schema using types from schema.ts
 */
-async function hydrateAgent({ dbAgent, agentId, baseUrl, apiKey, credentialStoreRegistry, sandboxConfig, userId }) {
+async function hydrateAgent({ dbAgent, executionContext, baseUrl, apiKey, credentialStoreRegistry, sandboxConfig }) {
 	try {
-		const taskHandler = createTaskHandler(await createTaskHandlerConfig({
-			tenantId: dbAgent.tenantId,
-			projectId: dbAgent.projectId,
-			agentId,
+		const taskHandlerConfig = await createTaskHandlerConfig({
+			executionContext,
 			subAgentId: dbAgent.id,
 			baseUrl,
 			apiKey,
-			sandboxConfig,
-			userId
-		}), credentialStoreRegistry);
+			sandboxConfig
+		});
+		const { tenantId, projectId, agentId } = executionContext;
+		const taskHandler = createTaskHandler(taskHandlerConfig, credentialStoreRegistry);
 		const agentCard = createAgentCard({
-			dbAgent,
+			dbAgent: {
+				...dbAgent,
+				tenantId,
+				projectId,
+				agentId
+			},
 			baseUrl
 		});
 		return {
 			subAgentId: dbAgent.id,
-			tenantId: dbAgent.tenantId,
-			projectId: dbAgent.projectId,
+			tenantId,
+			projectId,
 			agentId,
 			agentCard,
 			taskHandler
@@ -98,40 +100,30 @@ async function hydrateAgent({ dbAgent, agentId, baseUrl, apiKey, credentialStore
 }
 async function getRegisteredAgent(params) {
 	const { executionContext, credentialStoreRegistry, sandboxConfig } = params;
-	const { tenantId, projectId, agentId, subAgentId, baseUrl, apiKey } = executionContext;
-	const userId = getUserIdFromContext(executionContext);
-	let dbAgent;
-	if (!subAgentId) {
-		const agent = await getAgentWithDefaultSubAgent(dbClient_default)({ scopes: {
-			tenantId,
-			projectId,
-			agentId
-		} });
-		logger.info({ agent }, "agent with default sub agent");
-		if (!agent || !agent.defaultSubAgent) return null;
-		dbAgent = agent.defaultSubAgent;
-	} else {
-		const response = await getSubAgentById(dbClient_default)({
-			scopes: {
-				tenantId,
-				projectId,
-				agentId
-			},
+	const { agentId, subAgentId, baseUrl, apiKey, project } = executionContext;
+	const dbAgent = getSubAgentFromProject({
+		project,
+		agentId,
+		subAgentId
+	});
+	if (!dbAgent) {
+		logger.warn({
+			agentId,
 			subAgentId
-		});
-		if (!response) return null;
-		dbAgent = response;
+		}, "Could not find sub-agent in project");
+		return null;
 	}
-	if (!dbAgent) return null;
-	const agentFrameworkBaseUrl = `${baseUrl}/agents`;
+	logger.info({
+		agentId,
+		subAgentId: dbAgent.id
+	}, "Found sub-agent from project definition");
 	return hydrateAgent({
 		dbAgent,
-		agentId,
-		baseUrl: agentFrameworkBaseUrl,
+		executionContext,
+		baseUrl: `${baseUrl}/agents`,
 		credentialStoreRegistry,
 		apiKey,
-		sandboxConfig,
-		userId
+		sandboxConfig
 	});
 }
 

package/dist/data/conversations.d.ts

@@ -1,4 +1,4 @@
-import { AgentConversationHistoryConfig, Artifact, ConversationHistoryConfig, ConversationScopeOptions } from "@inkeep/agents-core";
+import { AgentConversationHistoryConfig, Artifact, ConversationHistoryConfig, ConversationScopeOptions, ResolvedRef } from "@inkeep/agents-core";
 
 //#region src/data/conversations.d.ts
 declare const compressionLocks: Map<string, Promise<any>>;
@@ -123,6 +123,7 @@ declare function getConversationScopedArtifacts(params: {
   projectId: string;
   conversationId: string;
   historyConfig: AgentConversationHistoryConfig;
+  ref: ResolvedRef;
 }): Promise<Artifact[]>;
 //#endregion
 export { compressConversationIfNeeded, compressionLocks, createDefaultConversationHistoryConfig, getConversationHistoryWithCompression, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };

package/dist/data/conversations.js

@@ -1,12 +1,12 @@
-import { getLogger } from "../logger.js";
+import { getLogger as getLogger$1 } from "../logger.js";
 import dbClient_default from "./db/dbClient.js";
 import { CONVERSATION_ARTIFACTS_LIMIT, CONVERSATION_HISTORY_DEFAULT_LIMIT as CONVERSATION_HISTORY_DEFAULT_LIMIT$1 } from "../constants/execution-limits/index.js";
 import { getCompressionConfigForModel } from "../utils/model-context-utils.js";
 import { ConversationCompressor } from "../services/ConversationCompressor.js";
-import { CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, createMessage, generateId, getConversationHistory } from "@inkeep/agents-core";
+import { CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, createMessage, generateId, getConversationHistory, getLedgerArtifacts } from "@inkeep/agents-core";
 
 //#region src/data/conversations.ts
-const logger = getLogger("conversations");
+const logger = getLogger$1("conversations");
 const compressionLocks = /* @__PURE__ */ new Map();
 /**
 * Creates default conversation history configuration
@@ -24,9 +24,10 @@ function createDefaultConversationHistoryConfig(mode = "full") {
 }
 /**
 * Extracts text content from A2A Message parts array
+* Escapes control characters to ensure proper JSON serialization for Dolt
 */
 function extractA2AMessageText(parts) {
-	return parts.filter((part) => part.kind === "text" && part.text).map((part) => part.text).join("");
+	return parts.filter((part) => part.kind === "text" && part.text).map((part) => part.text).join("").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f").replace(/\b/g, "\\b");
 }
 /**
 * Saves the result of an A2A client sendMessage call as a conversation message
@@ -470,7 +471,7 @@ function formatMessagesAsConversationHistory(messages) {
 * Uses the same scoping logic as getFormattedConversationHistory
 */
 async function getConversationScopedArtifacts(params) {
-	const { tenantId, projectId, conversationId, historyConfig } = params;
+	const { tenantId, projectId, conversationId, historyConfig, ref } = params;
 	if (!conversationId) return [];
 	try {
 		if (historyConfig.mode === "none") return [];
@@ -482,12 +483,10 @@ async function getConversationScopedArtifacts(params) {
 		});
 		if (visibleMessages.length === 0) return [];
 		if (visibleMessages.filter((msg) => !(msg.messageType === "system" && msg.content?.text?.includes("Previous conversation history truncated"))).map((msg) => msg.id).length === 0) return [];
-		const { getLedgerArtifacts: getLedgerArtifacts$1 } = await import("@inkeep/agents-core");
-		const dbClient = (await import("./db/dbClient.js")).default;
 		const visibleTaskIds = visibleMessages.map((msg) => msg.taskId).filter((taskId) => Boolean(taskId));
 		const referenceArtifacts = [];
 		for (const taskId of visibleTaskIds) {
-			const artifacts = await getLedgerArtifacts$1(dbClient)({
+			const artifacts = await getLedgerArtifacts(dbClient_default)({
 				scopes: {
 					tenantId,
 					projectId

package/dist/data/db/dbClient.d.ts

@@ -1,6 +1,6 @@
-import { DatabaseClient } from "@inkeep/agents-core";
+import * as _inkeep_agents_core2 from "@inkeep/agents-core";
 
 //#region src/data/db/dbClient.d.ts
-declare let dbClient: DatabaseClient;
+declare const dbClient: _inkeep_agents_core2.AgentsRunDatabaseClient;
 //#endregion
 export { dbClient as default };

package/dist/data/db/dbClient.js

@@ -1,16 +1,8 @@
 import { env } from "../../env.js";
-import { createDatabaseClient } from "@inkeep/agents-core";
-import { PGlite } from "@electric-sql/pglite";
-import * as schema from "@inkeep/agents-core/db/schema";
-import { drizzle } from "drizzle-orm/pglite";
+import { createAgentsRunDatabaseClient } from "@inkeep/agents-core";
 
 //#region src/data/db/dbClient.ts
-let dbClient;
-if (env.ENVIRONMENT === "test") dbClient = drizzle({
-	client: new PGlite(),
-	schema
-});
-else dbClient = createDatabaseClient({ connectionString: env.DATABASE_URL });
+const dbClient = createAgentsRunDatabaseClient({ connectionString: env.INKEEP_AGENTS_RUN_DATABASE_URL });
 var dbClient_default = dbClient;
 
 //#endregion