@inkeep/agents-core 0.0.0-dev-20250910233133 → 0.0.0-dev-20250910233441

package/dist/index.d.cts

@@ -0,0 +1,3992 @@
+import { z } from 'zod/v4';
+import { R as RequestSchemaDefinition, g as RequestSchemaConfig, C as ContextFetchDefinition, h as ContextConfigSelect, F as FetchDefinition, i as MCPToolConfig, S as ScopeConfig, a as ConversationHistoryConfig, j as PaginationConfig, A as AgentGraphInsert, k as AgentGraphUpdate, l as FullGraphDefinition, m as AgentRelationInsert, E as ExternalAgentRelationInsert, n as AgentRelationUpdate, o as AgentToolRelationUpdate, b as ToolMcpConfig, c as ToolServerCapabilities, M as McpToolDefinition, p as AgentInsert, q as AgentUpdate, r as AgentSelect, s as ApiKeySelect, t as ApiKeyInsert, u as ApiKeyUpdate, v as CreateApiKeyParams, w as ApiKeyCreateResult, x as ArtifactComponentSelect, y as ArtifactComponentInsert, z as ArtifactComponentUpdate, B as ContextCacheSelect, D as ContextCacheInsert, G as ContextConfigInsert, H as ContextConfigUpdate, I as ConversationSelect, J as ConversationInsert, d as ConversationMetadata, K as ConversationUpdate, L as CredentialReferenceSelect, N as ToolSelect, O as CredentialReferenceInsert, Q as CredentialReferenceUpdate, U as DataComponentSelect, V as DataComponentInsert, W as DataComponentUpdate, X as ExternalAgentInsert, Y as ExternalAgentSelect, Z as ExternalAgentUpdate, _ as Artifact, $ as LedgerArtifactSelect, f as MessageMetadata, e as MessageContent, a0 as MessageVisibility, a1 as MessageInsert, a2 as MessageUpdate, a3 as ProjectInfo, a4 as ProjectSelect, a5 as PaginationResult, a6 as ProjectResourceCounts, a7 as ProjectInsert, a8 as ProjectUpdate, a9 as TaskInsert, T as TaskMetadataConfig, aa as TaskSelect, ab as McpTool, ac as McpToolStatus, ad as ToolInsert, ae as ToolUpdate, af as ExecutionContext } from './utility-D2Lb-YAS.cjs';
+export { aT as A2AError, bn as A2ARequest, bo as A2AResponse, as as APIKeySecurityScheme, bs as AgentApiInsert, dg as AgentApiInsertSchema, br as AgentApiSelect, df as AgentApiSelectSchema, bt as AgentApiUpdate, dh as AgentApiUpdateSchema, cl as AgentArtifactComponentApiInsert, es as AgentArtifactComponentApiInsertSchema, ck as AgentArtifactComponentApiSelect, er as AgentArtifactComponentApiSelectSchema, cm as AgentArtifactComponentApiUpdate, et as AgentArtifactComponentApiUpdateSchema, ci as AgentArtifactComponentInsert, ep as AgentArtifactComponentInsertSchema, ch as AgentArtifactComponentSelect, eo as AgentArtifactComponentSelectSchema, cj as AgentArtifactComponentUpdate, eq as AgentArtifactComponentUpdateSchema, ao as AgentCapabilities, aC as AgentCard, cY as AgentConversationHistoryConfig, cc as AgentDataComponentApiInsert, eg as AgentDataComponentApiInsertSchema, cb as AgentDataComponentApiSelect, ef as AgentDataComponentApiSelectSchema, cd as AgentDataComponentApiUpdate, eh as AgentDataComponentApiUpdateSchema, c9 as AgentDataComponentInsert, ed as AgentDataComponentInsertSchema, c8 as AgentDataComponentSelect, ec as AgentDataComponentSelectSchema, ca as AgentDataComponentUpdate, ee as AgentDataComponentUpdateSchema, cK as AgentDefinition, bC as AgentGraphApiInsert, dw as AgentGraphApiInsertSchema, bB as AgentGraphApiSelect, dv as AgentGraphApiSelectSchema, bD as AgentGraphApiUpdate, dx as AgentGraphApiUpdateSchema, dt as AgentGraphInsertSchema, bA as AgentGraphSelect, ds as AgentGraphSelectSchema, du as AgentGraphUpdateSchema, dd as AgentInsertSchema, ap as AgentProvider, bw as AgentRelationApiInsert, dm as AgentRelationApiInsertSchema, bv as AgentRelationApiSelect, dl as AgentRelationApiSelectSchema, bx as AgentRelationApiUpdate, dn as AgentRelationApiUpdateSchema, dj as AgentRelationInsertSchema, by as AgentRelationQuery, dp as AgentRelationQuerySchema, bu as AgentRelationSelect, di as AgentRelationSelectSchema, dk as AgentRelationUpdateSchema, dc as AgentSelectSchema, aq as AgentSkill, cB as AgentToolRelationApiInsert, f5 as AgentToolRelationApiInsertSchema, cA as AgentToolRelationApiSelect, f4 as AgentToolRelationApiSelectSchema, cC as AgentToolRelationApiUpdate, f6 as AgentToolRelationApiUpdateSchema, cz as AgentToolRelationInsert, f2 as AgentToolRelationInsertSchema, cy as AgentToolRelationSelect, f1 as AgentToolRelationSelectSchema, f3 as AgentToolRelationUpdateSchema, de as AgentUpdateSchema, eA as AllAgentSchema, cq as AllAgentSelect, cu as ApiKeyApiCreationResponse, eF as ApiKeyApiCreationResponseSchema, cs as ApiKeyApiInsert, eG as ApiKeyApiInsertSchema, cr as ApiKeyApiSelect, eE as ApiKeyApiSelectSchema, ct as ApiKeyApiUpdate, eH as ApiKeyApiUpdateSchema, eC as ApiKeyInsertSchema, eB as ApiKeySelectSchema, eD as ApiKeyUpdateSchema, cf as ArtifactComponentApiInsert, em as ArtifactComponentApiInsertSchema, ce as ArtifactComponentApiSelect, el as ArtifactComponentApiSelectSchema, cg as ArtifactComponentApiUpdate, en as ArtifactComponentApiUpdateSchema, ej as ArtifactComponentInsertSchema, ei as ArtifactComponentSelectSchema, ek as ArtifactComponentUpdateSchema, av as AuthorizationCodeOAuthFlow, b7 as CancelTaskRequest, bi as CancelTaskResponse, bh as CancelTaskSuccessResponse, aw as ClientCredentialsOAuthFlow, aR as ContentTypeNotSupportedError, c3 as ContextCacheApiInsert, e3 as ContextCacheApiInsertSchema, c2 as ContextCacheApiSelect, e2 as ContextCacheApiSelectSchema, c4 as ContextCacheApiUpdate, e4 as ContextCacheApiUpdateSchema, cZ as ContextCacheEntry, e0 as ContextCacheInsertSchema, d$ as ContextCacheSelectSchema, c1 as ContextCacheUpdate, e1 as ContextCacheUpdateSchema, b_ as ContextConfigApiInsert, e$ as ContextConfigApiInsertSchema, bZ as ContextConfigApiSelect, e_ as ContextConfigApiSelectSchema, b$ as ContextConfigApiUpdate, f0 as ContextConfigApiUpdateSchema, eY as ContextConfigInsertSchema, eX as ContextConfigSelectSchema, eZ as ContextConfigUpdateSchema, bT as ConversationApiInsert, dT as ConversationApiInsertSchema, bS as ConversationApiSelect, dS as ConversationApiSelectSchema, bU as ConversationApiUpdate, dU as ConversationApiUpdateSchema, dQ as ConversationInsertSchema, cX as ConversationScopeOptions, dP as ConversationSelectSchema, dR as ConversationUpdateSchema, cw as CredentialReferenceApiInsert, eM as CredentialReferenceApiInsertSchema, cv as CredentialReferenceApiSelect, eL as CredentialReferenceApiSelectSchema, cx as CredentialReferenceApiUpdate, eN as CredentialReferenceApiUpdateSchema, eJ as CredentialReferenceInsertSchema, eI as CredentialReferenceSelectSchema, eK as CredentialReferenceUpdateSchema, c6 as DataComponentApiInsert, ea as DataComponentApiInsertSchema, c5 as DataComponentApiSelect, e9 as DataComponentApiSelectSchema, c7 as DataComponentApiUpdate, eb as DataComponentApiUpdateSchema, e7 as DataComponentBaseSchema, e6 as DataComponentInsertSchema, e5 as DataComponentSelectSchema, e8 as DataComponentUpdateSchema, am as DataPart, fk as ErrorResponseSchema, fl as ExistsResponseSchema, co as ExternalAgentApiInsert, ey as ExternalAgentApiInsertSchema, cn as ExternalAgentApiSelect, ex as ExternalAgentApiSelectSchema, cp as ExternalAgentApiUpdate, ez as ExternalAgentApiUpdateSchema, ev as ExternalAgentInsertSchema, bz as ExternalAgentRelationApiInsert, dr as ExternalAgentRelationApiInsertSchema, dq as ExternalAgentRelationInsertSchema, eu as ExternalAgentSelectSchema, ew as ExternalAgentUpdateSchema, c0 as FetchConfig, eV as FetchConfigSchema, eW as FetchDefinitionSchema, ai as FileBase, al as FilePart, aj as FileWithBytes, ak as FileWithUri, cI as FullGraphAgentInsert, ff as FullGraphAgentInsertSchema, fg as FullGraphDefinitionSchema, b9 as GetTaskPushNotificationConfigRequest, bm as GetTaskPushNotificationConfigResponse, bl as GetTaskPushNotificationConfigSuccessResponse, b6 as GetTaskRequest, bg as GetTaskResponse, bf as GetTaskSuccessResponse, at as HTTPAuthSecurityScheme, ft as HeadersScopeSchema, fy as IdParamsSchema, ax as ImplicitOAuthFlow, cJ as InternalAgentDefinition, aM as InternalError, aS as InvalidAgentResponseError, aL as InvalidParamsError, aJ as InvalidRequestError, aI as JSONParseError, b1 as JSONRPCError, b3 as JSONRPCErrorResponse, a$ as JSONRPCMessage, b0 as JSONRPCRequest, b2 as JSONRPCResult, cG as LedgerArtifactApiInsert, fb as LedgerArtifactApiInsertSchema, cF as LedgerArtifactApiSelect, fa as LedgerArtifactApiSelectSchema, cH as LedgerArtifactApiUpdate, fc as LedgerArtifactApiUpdateSchema, cD as LedgerArtifactInsert, f8 as LedgerArtifactInsertSchema, f7 as LedgerArtifactSelectSchema, cE as LedgerArtifactUpdate, f9 as LedgerArtifactUpdateSchema, fi as ListResponseSchema, d7 as MAX_ID_LENGTH, eQ as MCPToolConfigSchema, d6 as MIN_ID_LENGTH, c$ as McpAuthType, d0 as McpServerAuth, d2 as McpServerCapabilities, dM as McpToolDefinitionSchema, eO as McpToolSchema, bR as McpToolServerConfig, eP as McpToolServerConfigSchema, c_ as McpTranportType, d1 as McpTransportConfig, dK as McpTransportConfigSchema, aD as Message, bX as MessageApiInsert, dZ as MessageApiInsertSchema, bW as MessageApiSelect, dY as MessageApiSelectSchema, bY as MessageApiUpdate, d_ as MessageApiUpdateSchema, dW as MessageInsertSchema, cS as MessageMode, bp as MessagePart, cR as MessageRole, bV as MessageSelect, dV as MessageSelectSchema, aZ as MessageSendConfiguration, a_ as MessageSendParams, cQ as MessageType, dX as MessageUpdateSchema, aK as MethodNotFoundError, db as ModelSchema, cU as ModelSettings, da as ModelSettingsSchema, cT as Models, az as OAuth2SecurityScheme, au as OAuthFlows, aA as OpenIdConnectSecurityScheme, cP as Pagination, fz as PaginationQueryParamsSchema, fh as PaginationSchema, P as Part, ag as PartBase, ay as PasswordOAuthFlow, cN as ProjectApiInsert, fr as ProjectApiInsertSchema, cM as ProjectApiSelect, fq as ProjectApiSelectSchema, cO as ProjectApiUpdate, fs as ProjectApiUpdateSchema, fo as ProjectInsertSchema, fn as ProjectSelectSchema, fp as ProjectUpdateSchema, aU as PushNotificationAuthenticationInfo, aV as PushNotificationConfig, aP as PushNotificationNotSupportedError, fm as RemovedResponseSchema, aB as SecurityScheme, ar as SecuritySchemeBase, b4 as SendMessageRequest, bc as SendMessageResponse, bb as SendMessageSuccessResponse, b5 as SendStreamingMessageRequest, be as SendStreamingMessageResponse, bd as SendStreamingMessageSuccessResponse, b8 as SetTaskPushNotificationConfigRequest, bk as SetTaskPushNotificationConfigResponse, bj as SetTaskPushNotificationConfigSuccessResponse, fj as SingleResponseSchema, cW as StatusComponent, fd as StatusComponentSchema, fe as StatusUpdateSchema, cV as StatusUpdateSettings, d4 as TOOL_STATUS_VALUES, aF as Task, bG as TaskApiInsert, dC as TaskApiInsertSchema, bF as TaskApiSelect, dB as TaskApiSelectSchema, bH as TaskApiUpdate, dD as TaskApiUpdateSchema, bq as TaskArtifact, aH as TaskArtifactUpdateEvent, aX as TaskIdParams, dz as TaskInsertSchema, aO as TaskNotCancelableError, aN as TaskNotFoundError, aW as TaskPushNotificationConfig, aY as TaskQueryParams, bM as TaskRelationApiInsert, dI as TaskRelationApiInsertSchema, bL as TaskRelationApiSelect, dH as TaskRelationApiSelectSchema, bN as TaskRelationApiUpdate, dJ as TaskRelationApiUpdateSchema, bJ as TaskRelationInsert, dF as TaskRelationInsertSchema, bI as TaskRelationSelect, dE as TaskRelationSelectSchema, bK as TaskRelationUpdate, dG as TaskRelationUpdateSchema, ba as TaskResubscriptionRequest, dy as TaskSelectSchema, an as TaskState, aE as TaskStatus, aG as TaskStatusUpdateEvent, bE as TaskUpdate, dA as TaskUpdateSchema, fx as TenantIdParamsSchema, fu as TenantParamsSchema, fw as TenantProjectIdParamsSchema, fv as TenantProjectParamsSchema, ah as TextPart, bP as ToolApiInsert, eT as ToolApiInsertSchema, bO as ToolApiSelect, eS as ToolApiSelectSchema, bQ as ToolApiUpdate, eU as ToolApiUpdateSchema, cL as ToolDefinition, dO as ToolInsertSchema, dN as ToolSelectSchema, dL as ToolStatusSchema, eR as ToolUpdateSchema, d8 as URL_SAFE_ID_PATTERN, aQ as UnsupportedOperationError, d5 as VALID_RELATION_TYPES, d9 as resourceIdSchema, d3 as toolStatus } from './utility-D2Lb-YAS.cjs';
+import { CredentialStore } from './types/index.cjs';
+export { CorsConfig, ServerConfig, ServerOptions } from './types/index.cjs';
+import { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { s as schema } from './schema-E0ulMd3k.cjs';
+export { k as agentArtifactComponents, N as agentArtifactComponentsRelations, i as agentDataComponents, f as agentGraph, E as agentGraphRelations, d as agentRelations, O as agentRelationsRelations, m as agentToolRelations, H as agentToolRelationsRelations, b as agents, D as agentsRelations, r as apiKeys, G as apiKeysRelations, j as artifactComponents, M as artifactComponentsRelations, a as contextCache, C as contextCacheRelations, c as contextConfigs, B as contextConfigsRelations, n as conversations, K as conversationsRelations, u as credentialReferences, I as credentialReferencesRelations, h as dataComponents, e as externalAgents, F as externalAgentsRelations, q as ledgerArtifacts, w as ledgerArtifactsContextIdIdx, x as ledgerArtifactsTaskContextNameUnique, v as ledgerArtifactsTaskIdIdx, o as messages, L as messagesRelations, p as projects, z as projectsRelations, g as taskRelations, A as taskRelationsRelations, t as tasks, y as tasksRelations, l as tools, J as toolsRelations } from './schema-E0ulMd3k.cjs';
+import { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
+import * as hono from 'hono';
+import { Context, Next } from 'hono';
+import { ValidateFunction } from 'ajv';
+import { z as z$1 } from '@hono/zod-openapi';
+import { HTTPException } from 'hono/http-exception';
+import { Span, Tracer } from '@opentelemetry/api';
+export { generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences } from './validation/index.cjs';
+import 'zod';
+import 'drizzle-zod';
+import 'drizzle-orm/sqlite-core';
+import 'drizzle-orm';
+
+declare function createRequestSchema(schemas: RequestSchemaDefinition, config?: {
+    optional?: ('body' | 'headers' | 'query' | 'params')[];
+}): {
+    schemas: RequestSchemaDefinition;
+    config: RequestSchemaConfig;
+    toJsonSchema: () => {
+        schemas: Record<string, any>;
+        optional: ("query" | "body" | "headers" | "params")[] | undefined;
+    };
+    getZodSchemas: () => RequestSchemaDefinition;
+    getConfig: () => RequestSchemaConfig;
+};
+interface ContextConfigBuilderOptions {
+    id: string;
+    name: string;
+    description?: string;
+    requestContextSchema?: z.ZodSchema<any> | ReturnType<typeof createRequestSchema>;
+    contextVariables?: Record<string, ContextFetchDefinition>;
+    tenantId?: string;
+    projectId?: string;
+}
+declare class ContextConfigBuilder {
+    private config;
+    private baseURL;
+    private tenantId;
+    private projectId;
+    constructor(options: ContextConfigBuilderOptions);
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getRequestContextSchema(): {} | null;
+    getContextVariables(): Record<string, ContextFetchDefinition>;
+    /**
+     * Convert the builder to a plain object for database operations
+     */
+    toObject(): ContextConfigSelect;
+    withRequestContextSchema(schema: any): this;
+    withContextVariable(key: string, definition: ContextFetchDefinition): this;
+    withContextVariables(variables: Record<string, ContextFetchDefinition>): this;
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+    init(): Promise<void>;
+    private upsertContextConfig;
+    private parseErrorResponse;
+}
+declare function contextConfig(options: ContextConfigBuilderOptions): ContextConfigBuilder;
+declare function fetchDefinition(options: FetchDefinition | any): ContextFetchDefinition;
+
+/**
+ * Registry for managing credential stores in the application context
+ * Provides methods to register, retrieve, and manage credential stores
+ */
+declare class CredentialStoreRegistry {
+    private stores;
+    private logger;
+    constructor(initialStores?: CredentialStore[]);
+    /**
+     * Add a credential store to the registry
+     */
+    add(store: CredentialStore): void;
+    /**
+     * Get a credential store by ID
+     */
+    get(id: string): CredentialStore | undefined;
+    /**
+     * Get all registered credential stores
+     */
+    getAll(): CredentialStore[];
+    /**
+     * Get all credential store IDs
+     */
+    getIds(): string[];
+    /**
+     * Check if a credential store is registered
+     */
+    has(id: string): boolean;
+    /**
+     * Remove a credential store
+     */
+    remove(id: string): boolean;
+    /**
+     * Get the number of registered stores
+     */
+    size(): number;
+}
+
+type DatabaseClient = LibSQLDatabase<typeof schema>;
+interface DatabaseConfig {
+    url: string;
+    authToken?: string;
+    logger?: {
+        logQuery: (query: string, params: unknown[]) => void;
+    };
+}
+/**
+ * Creates a database client with the specified configuration
+ */
+declare function createDatabaseClient(config: DatabaseConfig): DatabaseClient;
+/**
+ * Creates an in-memory database client for testing
+ */
+declare function createInMemoryDatabaseClient(): DatabaseClient;
+
+interface TemplateContext {
+    [key: string]: unknown;
+}
+interface TemplateRenderOptions {
+    strict?: boolean;
+    preserveUnresolved?: boolean;
+}
+declare class TemplateEngine {
+    private static readonly DEFAULT_OPTIONS;
+    /**
+     * Render a template string with context data using JMESPath
+     */
+    static render(template: string, context: TemplateContext, options?: TemplateRenderOptions): string;
+    /**
+     * Process variable substitutions {{variable.path}} using JMESPath
+     */
+    private static processVariables;
+    /**
+     * Process built-in variables like $now, $env, etc.
+     */
+    private static processBuiltinVariable;
+    /**
+     * Check if template contains template variables
+     */
+    private static hasTemplateVariables;
+    /**
+     * Extract all template variables from a template
+     */
+    private static extractTemplateVariables;
+    /**
+     * Validate template syntax
+     */
+    static validateTemplate(template: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Preview template rendering with sample context
+     */
+    static preview(template: string, sampleContext: TemplateContext, options?: TemplateRenderOptions): {
+        rendered: string;
+        variables: string[];
+        errors: string[];
+    };
+}
+
+interface FetchResult {
+    data: unknown;
+    source: string;
+    durationMs: number;
+}
+declare class ContextFetcher {
+    private tenantId;
+    private projectId;
+    private defaultTimeout;
+    private credentialStoreRegistry?;
+    private credentialStuffer?;
+    private dbClient;
+    constructor(tenantId: string, projectId: string, dbClient: DatabaseClient, credentialStoreRegistry?: CredentialStoreRegistry, defaultTimeout?: number);
+    /**
+     * Fetch data according to a fetch definition
+     */
+    fetch(definition: ContextFetchDefinition, context: TemplateContext): Promise<unknown>;
+    private getCredential;
+    /**
+     * Resolve template variables in fetch configuration and inject credential headers
+     */
+    private resolveTemplateVariables;
+    /**
+     * Interpolate template variables in a string using TemplateEngine
+     */
+    private interpolateTemplate;
+    /**
+     * Interpolate template variables in an object recursively using TemplateEngine
+     */
+    private interpolateObjectTemplates;
+    /**
+     * Perform HTTP request
+     */
+    private performRequest;
+    /**
+     * Transform response data using JMESPath
+     */
+    private transformResponse;
+    /**
+     * Validate response against JSON Schema
+     */
+    private validateResponseWithJsonSchema;
+    /**
+     * Test a fetch definition without caching
+     */
+    test(definition: ContextFetchDefinition, context: TemplateContext): Promise<{
+        success: boolean;
+        data?: unknown;
+        error?: string;
+        durationMs: number;
+    }>;
+    /**
+     * Get fetcher statistics
+     */
+    getStats(): {
+        tenantId: string;
+        defaultTimeout: number;
+    };
+}
+
+interface ResolvedContext {
+    [templateKey: string]: unknown;
+}
+interface ContextResolutionOptions {
+    triggerEvent: 'initialization' | 'invocation';
+    conversationId: string;
+    requestContext?: Record<string, unknown>;
+    tenantId: string;
+}
+interface ContextResolutionResult {
+    resolvedContext: ResolvedContext;
+    requestContext: Record<string, unknown>;
+    fetchedDefinitions: string[];
+    cacheHits: string[];
+    cacheMisses: string[];
+    errors: Array<{
+        definitionId: string;
+        error: string;
+    }>;
+    totalDurationMs: number;
+}
+declare class ContextResolver {
+    private fetcher;
+    private cache;
+    private tenantId;
+    private projectId;
+    constructor(tenantId: string, projectId: string, dbClient: DatabaseClient, credentialStoreRegistry?: CredentialStoreRegistry);
+    /**
+     * Resolve all contexts for a given configuration and trigger event
+     */
+    resolve(contextConfig: ContextConfigSelect, options: ContextResolutionOptions): Promise<ContextResolutionResult>;
+    /**
+     * Resolve a single context variable
+     */
+    private resolveSingleFetchDefinition;
+    /**
+     * Resolve the request context for a given conversation
+     */
+    resolveRequestContext(conversationId: string, contextConfigId: string): Promise<Record<string, unknown>>;
+    /**
+     * Create a hash of the request context for cache invalidation
+     */
+    private createRequestHash;
+    /**
+     * Clear cache
+     */
+    clearCache(tenantId: string, projectId: string, conversationId: string): Promise<void>;
+}
+
+declare function determineContextTrigger(tenantId: string, projectId: string, conversationId: string, dbClient: DatabaseClient): Promise<'initialization' | 'invocation'>;
+declare function handleContextConfigChange(tenantId: string, projectId: string, conversationId: string, graphId: string, newContextConfigId: string, dbClient: DatabaseClient, credentialStores?: CredentialStoreRegistry): Promise<void>;
+declare function handleContextResolution(tenantId: string, projectId: string, conversationId: string, graphId: string, requestContext: Record<string, unknown>, dbClient: DatabaseClient, credentialStores?: CredentialStoreRegistry): Promise<ResolvedContext | null>;
+
+interface CacheEntry {
+    contextConfigId: string;
+    contextVariableKey: string;
+    conversationId: string;
+    value: unknown;
+    requestHash?: string;
+    tenantId: string;
+}
+/**
+ * Context cache with request hash-based invalidation and graceful error handling.
+ *
+ * Implements conversation-scoped caching with smart cache invalidation based on
+ * request hash changes. All cache errors are treated as cache misses to ensure
+ * system reliability.
+ */
+declare class ContextCache {
+    private tenantId;
+    private projectId;
+    private dbClient;
+    constructor(tenantId: string, projectId: string, dbClient: DatabaseClient);
+    /**
+     * Get cached context data for a conversation
+     */
+    get({ conversationId, contextConfigId, contextVariableKey, requestHash, }: {
+        conversationId: string;
+        contextConfigId: string;
+        contextVariableKey: string;
+        requestHash?: string;
+    }): Promise<CacheEntry | null>;
+    /**
+     * Set cached context data for a conversation
+     */
+    set(entry: CacheEntry): Promise<void>;
+    /**
+     * Clear cache entries for a specific conversation
+     */
+    clearConversation(tenantId: string, projectId: string, conversationId: string): Promise<void>;
+    /**
+     * Clear all cache entries for a specific context configuration
+     */
+    clearContextConfig(tenantId: string, projectId: string, contextConfigId: string): Promise<void>;
+    /**
+     * Clean up expired or orphaned cache entries
+     */
+    cleanup(): Promise<void>;
+    invalidateInvocationDefinitions(tenantId: string, projectId: string, conversationId: string, contextConfigId: string, definitionIds: string[]): Promise<void>;
+    invalidateRequestContext(tenantId: string, projectId: string, conversationId: string, contextConfigId: string): Promise<void>;
+}
+
+/**
+ * Create default credential stores based on environment variables
+ */
+declare function createDefaultCredentialStores(): CredentialStore[];
+
+/**
+ * KeyChainStore - Cross-platform system keychain credential storage
+ *
+ * Uses the native OS credential storage:
+ * - macOS: Keychain
+ * - Windows: Credential Vault
+ * - Linux: Secret Service API/libsecret
+ *
+ * Requires the 'keytar' npm package to be installed.
+ * Falls back gracefully if keytar is not available.
+ *
+ * ## macOS Permission Handling
+ *
+ * On macOS, when your Node.js app first calls keytar operations:
+ * - `setPassword()` creates a new Keychain item (no prompt required)
+ * - `getPassword()` may prompt the user for permission on first access
+ * - Users can click "Allow", "Always Allow", or "Deny"
+ * - If denied, keytar returns `null` which this implementation handles gracefully
+ * - The calling binary (usually `node`) will be shown in the permission prompt
+ * - For better UX in packaged apps, consider code signing and app bundling
+ *
+ * This implementation handles all permission scenarios gracefully:
+ * - Returns `null` when access is denied or credentials don't exist
+ * - Logs errors for debugging permission issues
+ * - Never throws on permission denial, only on system-level errors
+ */
+declare class KeyChainStore implements CredentialStore {
+    readonly id: string;
+    readonly type = "keychain";
+    private readonly service;
+    private readonly logger;
+    private keytarAvailable;
+    private keytar;
+    private initializationPromise;
+    constructor(id: string, servicePrefix?: string);
+    /**
+     * Initialize keytar dynamically to handle optional availability
+     */
+    private initializeKeytar;
+    /**
+     * Get a credential from the keychain
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Set a credential in the keychain
+     */
+    set(key: string, value: string): Promise<void>;
+    /**
+     * Check if a credential exists in the keychain
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Delete a credential from the keychain
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Find all credentials for this service
+     * Useful for debugging and listing stored credentials
+     */
+    findAllCredentials(): Promise<Array<{
+        account: string;
+        password: string;
+    }>>;
+    /**
+     * Clear all credentials for this service
+     * WARNING: This will delete all credentials stored under this service
+     */
+    clearAll(): Promise<number>;
+}
+/**
+ * Factory function to create KeyChainStore
+ * Provides consistent initialization and optional configuration
+ *
+ * ## Usage Recommendations for macOS Permission Handling
+ *
+ * 1. **First-time setup**: Inform users that they may see permission prompts
+ * 2. **Error handling**: Check for `null` returns from `get()` operations
+ * 3. **User guidance**: If credentials can't be retrieved, guide users to:
+ *    - Check Keychain Access app for denied permissions
+ *    - Re-run the application if they accidentally clicked "Deny"
+ * 4. **Development**: Use a consistent `servicePrefix` to avoid permission prompt spam
+ * 5. **Production**: Consider code-signing your distributed app for better permission prompts
+ *
+ * Example usage with permission handling:
+ * ```typescript
+ * const store = createKeyChainStore('my-app');
+ *
+ * // Always check for null when retrieving
+ * const apiKey = await store.get('api-key');
+ * if (!apiKey) {
+ *   console.log('API key not found or access denied');
+ *   // Guide user to check permissions or re-enter credentials
+ * }
+ * ```
+ */
+declare function createKeyChainStore(id: string, options?: {
+    servicePrefix?: string;
+}): KeyChainStore;
+
+/**
+ * In-memory credential store implementation
+ * Automatically loads environment variables prefixed with CREDENTIAL_STORE_ on initialization
+ * Note: Runtime credentials are lost when the server restarts, but env vars are reloaded
+ */
+declare class InMemoryCredentialStore implements CredentialStore {
+    readonly id: string;
+    readonly type = "memory";
+    private credentials;
+    constructor(id?: string);
+    /**
+     * Get a credential from the in memory store.
+     * If the key is not found in the in memory store then it is loaded from environment variables.
+     * If the key is not found in the environment variables or in the in memory store then returns null.
+     * @param key - The key of the credential to get
+     * @returns The credential value or null if not found
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Set a credential in the in memory store.
+     * @param key - The key of the credential to set
+     * @param value - The value of the credential to set
+     */
+    set(key: string, value: string): Promise<void>;
+    /**
+     * Check if a credential exists in the in memory store.
+     * @param key - The key of the credential to check
+     * @returns True if the credential exists, false otherwise
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Delete a credential from the in memory store.
+     * @param key - The key of the credential to delete
+     * @returns True if the credential was deleted, false otherwise
+     */
+    delete(key: string): Promise<boolean>;
+}
+
+interface NangoConfig {
+    secretKey: string;
+    apiUrl?: string;
+}
+/**
+ * Nango-based CredentialStore that fetches OAuth credentials from Nango API
+ * Uses connectionId and providerConfigKey from metadata to fetch live credentials
+ */
+declare class NangoCredentialStore implements CredentialStore {
+    readonly id: string;
+    readonly type = "nango";
+    private nangoConfig;
+    private nangoClient;
+    constructor(id: string, config: NangoConfig);
+    private getAccessToken;
+    private sanitizeMetadata;
+    /**
+     * Fetch credentials from Nango API using connection information
+     * @param connectionId - The connection ID for the Nango connection
+     * @param providerConfigKey - The provider config key for the Nango connection
+     * @returns The credential data or null if the credentials are not found
+     */
+    private fetchCredentialsFromNango;
+    /**
+     * Get credentials by key - implements CredentialStore interface
+     * Key format: JSON string with connectionId and providerConfigKey
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Set credentials - not supported for Nango (OAuth flow handles this)
+     */
+    set(_key: string, _value: string): Promise<void>;
+    /**
+     * Check if credentials exist by attempting to fetch them
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Delete credentials - not supported for Nango (revoke through Nango dashboard)
+     */
+    delete(key: string): Promise<boolean>;
+}
+/**
+ * Factory function to create NangoCredentialStore
+ * Automatically reads NANGO_SECRET_KEY from environment and validates it
+ */
+declare function createNangoCredentialStore(id: string, config?: Partial<NangoConfig>): NangoCredentialStore;
+
+/**
+ * Logger interface for core package components
+ * Allows services to inject their own logger implementation
+ */
+interface Logger$1 {
+    error(data: any, message: string): void;
+    warn(data: any, message: string): void;
+    info(data: any, message: string): void;
+    debug(data: any, message: string): void;
+}
+/**
+ * Default console logger implementation
+ */
+declare class ConsoleLogger implements Logger$1 {
+    private name;
+    constructor(name: string);
+    error(data: any, message: string): void;
+    warn(data: any, message: string): void;
+    info(data: any, message: string): void;
+    debug(data: any, message: string): void;
+}
+/**
+ * No-op logger that silently ignores all log calls
+ */
+declare class NoOpLogger implements Logger$1 {
+    error(_data: any, _message: string): void;
+    warn(_data: any, _message: string): void;
+    info(_data: any, _message: string): void;
+    debug(_data: any, _message: string): void;
+}
+/**
+ * Logger factory configuration
+ */
+interface LoggerFactoryConfig {
+    defaultLogger?: Logger$1;
+    loggerFactory?: (name: string) => Logger$1;
+}
+/**
+ * Global logger factory singleton
+ */
+declare class LoggerFactory {
+    private config;
+    private loggers;
+    /**
+     * Configure the logger factory
+     */
+    configure(config: LoggerFactoryConfig): void;
+    /**
+     * Get or create a logger instance
+     */
+    getLogger(name: string): Logger$1;
+    /**
+     * Reset factory to default state
+     */
+    reset(): void;
+}
+declare const loggerFactory: LoggerFactory;
+/**
+ * Convenience function to get a logger
+ */
+declare function getLogger(name: string): Logger$1;
+/**
+ * Configure the global logger factory
+ * This should be called once at application startup
+ *
+ * Example usage:
+ * ```typescript
+ * // In your service initialization
+ * import { configureLogging } from '@inkeep/agents-core';
+ * import { getLogger as getPinoLogger } from './logger.j';
+ *
+ * configureLogging({
+ *   loggerFactory: (name) => getPinoLogger(name)
+ * });
+ * ```
+ */
+declare function configureLogging(config: LoggerFactoryConfig): void;
+
+interface SharedServerConfig {
+    timeout?: number;
+    activeTools?: string[];
+}
+interface McpStreamableHttpConfig extends SharedServerConfig {
+    type: 'streamable_http';
+    url: string | URL;
+    headers?: Record<string, string>;
+    requestInit?: StreamableHTTPClientTransportOptions['requestInit'];
+    eventSourceInit?: SSEClientTransportOptions['eventSourceInit'];
+    reconnectionOptions?: StreamableHTTPClientTransportOptions['reconnectionOptions'];
+    sessionId?: StreamableHTTPClientTransportOptions['sessionId'];
+}
+interface McpSSEConfig extends SharedServerConfig {
+    type: 'sse';
+    url: string | URL;
+    headers?: Record<string, string>;
+    eventSourceInit?: SSEClientTransportOptions['eventSourceInit'];
+}
+type McpServerConfig = McpStreamableHttpConfig | McpSSEConfig;
+interface McpClientOptions {
+    name: string;
+    version?: string;
+    server: McpServerConfig;
+    capabilities?: ClientCapabilities;
+    timeout?: number;
+}
+declare class McpClient {
+    name: string;
+    private client;
+    private readonly timeout;
+    private transport?;
+    private serverConfig;
+    private connected;
+    constructor(opts: McpClientOptions);
+    connect(): Promise<void>;
+    private connectSSE;
+    private connectHttp;
+    disconnect(): Promise<void>;
+    private validateSelectedTools;
+    private selectTools;
+    tools(): Promise<Record<string, any>>;
+}
+
+/**
+ * Context object for credential operations
+ */
+interface CredentialContext {
+    /** Tenant identifier */
+    tenantId: string;
+    /** Project identifier */
+    projectId: string;
+    /** Conversation identifier */
+    conversationId?: string;
+    /** Context configuration identifier */
+    contextConfigId?: string;
+    /** Additional context data */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Base credential data structure containing headers and metadata
+ */
+interface CredentialData {
+    /** HTTP headers for authentication */
+    headers: Record<string, string>;
+    /** Additional metadata for the credentials */
+    metadata?: Record<string, any>;
+}
+/**
+ * Credential store reference for lookups
+ */
+interface CredentialStoreReference {
+    /** Framework credential store ID */
+    credentialStoreId: string;
+    /** Configuration parameters for credential retrieval */
+    retrievalParams: Record<string, unknown>;
+}
+interface CredentialResolverInput {
+    context: CredentialContext;
+    mcpType?: MCPToolConfig['mcpType'];
+    storeReference?: CredentialStoreReference;
+    headers?: Record<string, string>;
+}
+/**
+ * Interface for context resolver (optional)
+ */
+interface ContextResolverInterface {
+    resolveRequestContext(conversationId: string, contextConfigId: string): Promise<Record<string, unknown>>;
+}
+/**
+ * Manages credential retrieval and injection for MCP tools
+ * Uses CredentialStoreRegistry for credential store management
+ */
+declare class CredentialStuffer {
+    private credentialStoreRegistry;
+    private contextResolver?;
+    private readonly logger;
+    constructor(credentialStoreRegistry: CredentialStoreRegistry, contextResolver?: ContextResolverInterface | undefined, logger?: Logger$1);
+    /**
+     * Retrieve credentials from credential store registry
+     */
+    getCredentials(context: CredentialContext, storeReference: CredentialStoreReference, mcpType?: MCPToolConfig['mcpType']): Promise<CredentialData | null>;
+    /**
+     * Generate credential lookup key based on store type
+     */
+    private generateCredentialKey;
+    /**
+     * Get credentials from request context
+     */
+    getCredentialsFromRequestContext(credentialContext: CredentialContext, headers: Record<string, string>): Promise<CredentialData | null>;
+    /**
+     * Get credential headers for MCP server configuration
+     */
+    getCredentialHeaders({ context, mcpType, storeReference, headers, }: CredentialResolverInput): Promise<Record<string, string>>;
+    /**
+     * Build MCP server configuration with credentials
+     */
+    buildMcpServerConfig(context: CredentialContext, tool: MCPToolConfig, storeReference?: CredentialStoreReference): Promise<McpServerConfig>;
+}
+
+declare const getAgentGraph: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<{
+    name: string;
+    description: string | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    defaultAgentId: string;
+    contextConfigId: string | null;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    statusUpdates: {
+        enabled?: boolean | undefined;
+        numEvents?: number | undefined;
+        timeInSeconds?: number | undefined;
+        prompt?: string | undefined;
+        statusComponents?: {
+            type: string;
+            description?: string | undefined;
+            detailsSchema?: {
+                type: "object";
+                properties: Record<string, any>;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | null;
+    graphPrompt: string | null;
+    stopWhen: {
+        transferCountIs?: number;
+    } | null;
+} | undefined>;
+declare const getAgentGraphById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<{
+    name: string;
+    description: string | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    defaultAgentId: string;
+    contextConfigId: string | null;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    statusUpdates: {
+        enabled?: boolean | undefined;
+        numEvents?: number | undefined;
+        timeInSeconds?: number | undefined;
+        prompt?: string | undefined;
+        statusComponents?: {
+            type: string;
+            description?: string | undefined;
+            detailsSchema?: {
+                type: "object";
+                properties: Record<string, any>;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | null;
+    graphPrompt: string | null;
+    stopWhen: {
+        transferCountIs?: number;
+    } | null;
+} | null>;
+declare const getAgentGraphWithDefaultAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<{
+    name: string;
+    description: string | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    defaultAgentId: string;
+    contextConfigId: string | null;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    statusUpdates: {
+        enabled?: boolean | undefined;
+        numEvents?: number | undefined;
+        timeInSeconds?: number | undefined;
+        prompt?: string | undefined;
+        statusComponents?: {
+            type: string;
+            description?: string | undefined;
+            detailsSchema?: {
+                type: "object";
+                properties: Record<string, any>;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | null;
+    graphPrompt: string | null;
+    stopWhen: {
+        transferCountIs?: number;
+    } | null;
+    defaultAgent: {
+        name: string;
+        prompt: string;
+        description: string;
+        id: string;
+        tenantId: string;
+        projectId: string;
+        createdAt: string;
+        updatedAt: string;
+        models: {
+            base?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+            structuredOutput?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+            summarizer?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | null;
+        stopWhen: {
+            stepCountIs?: number;
+        } | null;
+        conversationHistoryConfig: ConversationHistoryConfig | null;
+    };
+} | null>;
+declare const listAgentGraphs: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<{
+    name: string;
+    description: string | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    defaultAgentId: string;
+    contextConfigId: string | null;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    statusUpdates: {
+        enabled?: boolean | undefined;
+        numEvents?: number | undefined;
+        timeInSeconds?: number | undefined;
+        prompt?: string | undefined;
+        statusComponents?: {
+            type: string;
+            description?: string | undefined;
+            detailsSchema?: {
+                type: "object";
+                properties: Record<string, any>;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | null;
+    graphPrompt: string | null;
+    stopWhen: {
+        transferCountIs?: number;
+    } | null;
+}[]>;
+declare const listAgentGraphsPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        name: string;
+        description: string | null;
+        defaultAgentId: string;
+        contextConfigId: string | null;
+        models: {
+            base?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+            structuredOutput?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+            summarizer?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | null;
+        statusUpdates: {
+            enabled?: boolean | undefined;
+            numEvents?: number | undefined;
+            timeInSeconds?: number | undefined;
+            prompt?: string | undefined;
+            statusComponents?: {
+                type: string;
+                description?: string | undefined;
+                detailsSchema?: {
+                    type: "object";
+                    properties: Record<string, any>;
+                    required?: string[] | undefined;
+                } | undefined;
+            }[] | undefined;
+        } | null;
+        graphPrompt: string | null;
+        stopWhen: {
+            transferCountIs?: number;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const createAgentGraph: (db: DatabaseClient) => (data: AgentGraphInsert) => Promise<{
+    name: string;
+    description: string | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    defaultAgentId: string;
+    contextConfigId: string | null;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    statusUpdates: {
+        enabled?: boolean | undefined;
+        numEvents?: number | undefined;
+        timeInSeconds?: number | undefined;
+        prompt?: string | undefined;
+        statusComponents?: {
+            type: string;
+            description?: string | undefined;
+            detailsSchema?: {
+                type: "object";
+                properties: Record<string, any>;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | null;
+    graphPrompt: string | null;
+    stopWhen: {
+        transferCountIs?: number;
+    } | null;
+}>;
+declare const updateAgentGraph: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+    data: AgentGraphUpdate;
+}) => Promise<{
+    name: string;
+    description: string | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    defaultAgentId: string;
+    contextConfigId: string | null;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    statusUpdates: {
+        enabled?: boolean | undefined;
+        numEvents?: number | undefined;
+        timeInSeconds?: number | undefined;
+        prompt?: string | undefined;
+        statusComponents?: {
+            type: string;
+            description?: string | undefined;
+            detailsSchema?: {
+                type: "object";
+                properties: Record<string, any>;
+                required?: string[] | undefined;
+            } | undefined;
+        }[] | undefined;
+    } | null;
+    graphPrompt: string | null;
+    stopWhen: {
+        transferCountIs?: number;
+    } | null;
+}>;
+declare const deleteAgentGraph: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<boolean>;
+/**
+ * Helper function to fetch component relationships using efficient joins
+ */
+declare const fetchComponentRelationships: (db: DatabaseClient) => <T extends Record<string, any>>(scopes: ScopeConfig, agentIds: string[], config: {
+    relationTable: any;
+    componentTable: any;
+    relationIdField: any;
+    componentIdField: any;
+    selectFields: Record<string, any>;
+}) => Promise<Record<string, T>>;
+declare const getGraphAgentInfos: (db: DatabaseClient) => ({ scopes, graphId, agentId, }: {
+    scopes: ScopeConfig;
+    graphId: string;
+    agentId: string;
+}) => Promise<{
+    id: string;
+    name: string;
+    description: string;
+}[]>;
+declare const getFullGraphDefinition: (db: DatabaseClient) => ({ scopes: { tenantId, projectId }, graphId, }: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<FullGraphDefinition | null>;
+/**
+ * Upsert an agent graph (create if it doesn't exist, update if it does)
+ */
+declare const upsertAgentGraph: (db: DatabaseClient) => (params: {
+    data: AgentGraphInsert;
+}) => Promise<any>;
+
+declare const getAgentRelationById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    relationId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+} | undefined>;
+declare const listAgentRelations: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        graphId: string;
+        sourceAgentId: string;
+        targetAgentId: string | null;
+        externalAgentId: string | null;
+        relationType: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getAgentRelations: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+    agentId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+}[]>;
+declare const getAgentRelationsByGraph: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+}[]>;
+declare const getAgentRelationsBySource: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    sourceAgentId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        graphId: string;
+        sourceAgentId: string;
+        targetAgentId: string | null;
+        externalAgentId: string | null;
+        relationType: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getAgentRelationsByTarget: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    targetAgentId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        graphId: string;
+        sourceAgentId: string;
+        targetAgentId: string | null;
+        externalAgentId: string | null;
+        relationType: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getExternalAgentRelations: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    externalAgentId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        graphId: string;
+        sourceAgentId: string;
+        targetAgentId: string | null;
+        externalAgentId: string | null;
+        relationType: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getRelatedAgentsForGraph: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+    agentId: string;
+}) => Promise<{
+    internalRelations: {
+        id: string;
+        name: string;
+        description: string;
+        relationType: string | null;
+    }[];
+    externalRelations: {
+        id: string;
+        relationType: string | null;
+        externalAgent: {
+            id: string;
+            name: string;
+            description: string;
+            baseUrl: string;
+        };
+    }[];
+}>;
+declare const createAgentRelation: (db: DatabaseClient) => (params: AgentRelationInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+}>;
+/**
+ * Check if agent relation exists by graph, source, target, and relation type
+ */
+declare const getAgentRelationByParams: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+    sourceAgentId: string;
+    targetAgentId?: string;
+    externalAgentId?: string;
+    relationType: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+} | undefined>;
+/**
+ * Upsert agent relation (create if it doesn't exist, no-op if it does)
+ */
+declare const upsertAgentRelation: (db: DatabaseClient) => (params: AgentRelationInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+}>;
+declare const createExternalAgentRelation: (db: DatabaseClient) => (params: ExternalAgentRelationInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+}>;
+declare const updateAgentRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    relationId: string;
+    data: AgentRelationUpdate;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    createdAt: string;
+    updatedAt: string;
+    sourceAgentId: string;
+    targetAgentId: string | null;
+    externalAgentId: string | null;
+    relationType: string | null;
+}>;
+declare const deleteAgentRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    relationId: string;
+}) => Promise<boolean>;
+declare const deleteAgentRelationsByGraph: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<boolean>;
+declare const createAgentToolRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    relationId?: string;
+    data: {
+        agentId: string;
+        toolId: string;
+    };
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    agentId: string;
+    toolId: string;
+}>;
+declare const updateAgentToolRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    relationId: string;
+    data: AgentToolRelationUpdate;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    agentId: string;
+    toolId: string;
+}>;
+declare const deleteAgentToolRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    relationId: string;
+}) => Promise<boolean>;
+declare const deleteAgentToolRelationByAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+declare const getAgentToolRelationById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    relationId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    agentId: string;
+    toolId: string;
+} | undefined>;
+declare const getAgentToolRelationByAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        agentId: string;
+        toolId: string;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getAgentToolRelationByTool: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    toolId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        agentId: string;
+        toolId: string;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const listAgentToolRelations: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        agentId: string;
+        toolId: string;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const listAgentToolRelationsByAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        agentId: string;
+        toolId: string;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getToolsForAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        id: string;
+        tenantId: string;
+        agentId: string;
+        toolId: string;
+        createdAt: string;
+        updatedAt: string;
+        tool: {
+            id: string;
+            name: string;
+            config: {
+                type: "mcp";
+                mcp: ToolMcpConfig;
+            };
+            createdAt: string;
+            updatedAt: string;
+            capabilities: ToolServerCapabilities | null;
+            lastHealthCheck: string | null;
+            lastToolsSync: string | null;
+            lastError: string | null;
+            availableTools: McpToolDefinition[] | null;
+            credentialReferenceId: string | null;
+        };
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getAgentsForTool: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    toolId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        id: string;
+        tenantId: string;
+        agentId: string;
+        toolId: string;
+        createdAt: string;
+        updatedAt: string;
+        agent: {
+            id: string;
+            name: string;
+            description: string;
+            prompt: string;
+            createdAt: string;
+            updatedAt: string;
+        };
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const validateInternalAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+declare const validateExternalAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+
+declare const getAgentById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<{
+    name: string;
+    prompt: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    stopWhen: {
+        stepCountIs?: number;
+    } | null;
+    conversationHistoryConfig: ConversationHistoryConfig | null;
+} | undefined>;
+declare const listAgents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<{
+    name: string;
+    prompt: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    stopWhen: {
+        stepCountIs?: number;
+    } | null;
+    conversationHistoryConfig: ConversationHistoryConfig | null;
+}[]>;
+declare const listAgentsPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        name: string;
+        description: string;
+        prompt: string;
+        conversationHistoryConfig: ConversationHistoryConfig | null;
+        models: {
+            base?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+            structuredOutput?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+            summarizer?: {
+                model?: string | undefined;
+                providerOptions?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | null;
+        stopWhen: {
+            stepCountIs?: number;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const createAgent: (db: DatabaseClient) => (params: AgentInsert) => Promise<{
+    name: string;
+    prompt: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    stopWhen: {
+        stepCountIs?: number;
+    } | null;
+    conversationHistoryConfig: ConversationHistoryConfig | null;
+}>;
+declare const updateAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    data: AgentUpdate;
+}) => Promise<{
+    name: string;
+    prompt: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    stopWhen: {
+        stepCountIs?: number;
+    } | null;
+    conversationHistoryConfig: ConversationHistoryConfig | null;
+}>;
+/**
+ * Upsert agent (create if it doesn't exist, update if it does)
+ */
+declare const upsertAgent: (db: DatabaseClient) => (params: {
+    data: AgentInsert;
+}) => Promise<AgentSelect>;
+declare const deleteAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+declare const getAgentsByIds: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentIds: string[];
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    name: string;
+    description: string;
+    prompt: string;
+    conversationHistoryConfig: ConversationHistoryConfig | null;
+    models: {
+        base?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        structuredOutput?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+        summarizer?: {
+            model?: string | undefined;
+            providerOptions?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null;
+    stopWhen: {
+        stepCountIs?: number;
+    } | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const getAgentInGraphContext: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+    agentId: string;
+}) => Promise<{
+    id: string;
+    name: string;
+    description: string;
+    prompt: string;
+    tenantId: string;
+    graphId: string;
+    sourceAgentId: string;
+}[]>;
+
+declare const getApiKeyById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    publicId: string;
+    keyHash: string;
+    keyPrefix: string;
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+} | undefined>;
+declare const getApiKeyByPublicId: (db: DatabaseClient) => (publicId: string) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    publicId: string;
+    keyHash: string;
+    keyPrefix: string;
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+} | undefined>;
+declare const listApiKeys: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId?: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    publicId: string;
+    keyHash: string;
+    keyPrefix: string;
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const listApiKeysPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+    graphId?: string;
+}) => Promise<{
+    data: ApiKeySelect[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const createApiKey: (db: DatabaseClient) => (params: ApiKeyInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    publicId: string;
+    keyHash: string;
+    keyPrefix: string;
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}>;
+declare const updateApiKey: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+    data: ApiKeyUpdate;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    publicId: string;
+    keyHash: string;
+    keyPrefix: string;
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}>;
+declare const deleteApiKey: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<boolean>;
+declare const hasApiKey: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<boolean>;
+declare const updateApiKeyLastUsed: (db: DatabaseClient) => (id: string) => Promise<void>;
+declare const countApiKeys: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId?: string;
+}) => Promise<number>;
+/**
+ * Create a new API key
+ * Returns both the API key record and the full key (which should be shown to the user only once)
+ */
+declare const generateAndCreateApiKey: (params: CreateApiKeyParams, db: DatabaseClient) => Promise<ApiKeyCreateResult>;
+/**
+ * Validate an API key and return the associated record if valid
+ */
+declare const validateAndGetApiKey: (key: string, db: DatabaseClient) => Promise<ApiKeySelect | null>;
+
+declare const getArtifactComponentById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    summaryProps: Record<string, unknown> | null;
+    fullProps: Record<string, unknown> | null;
+} | undefined>;
+declare const listArtifactComponents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    name: string;
+    description: string;
+    summaryProps: Record<string, unknown> | null;
+    fullProps: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const listArtifactComponentsPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: ArtifactComponentSelect[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const createArtifactComponent: (db: DatabaseClient) => (params: ArtifactComponentInsert) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    summaryProps: Record<string, unknown> | null;
+    fullProps: Record<string, unknown> | null;
+}>;
+declare const updateArtifactComponent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+    data: ArtifactComponentUpdate;
+}) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    summaryProps: Record<string, unknown> | null;
+    fullProps: Record<string, unknown> | null;
+}>;
+declare const deleteArtifactComponent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<boolean>;
+declare const getArtifactComponentsForAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    name: string;
+    description: string;
+    summaryProps: Record<string, unknown> | null;
+    fullProps: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const associateArtifactComponentWithAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    artifactComponentId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    agentId: string;
+    artifactComponentId: string;
+}>;
+declare const removeArtifactComponentFromAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    artifactComponentId: string;
+}) => Promise<boolean>;
+declare const deleteAgentArtifactComponentRelationByAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+declare const getAgentsUsingArtifactComponent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    artifactComponentId: string;
+}) => Promise<{
+    agentId: string;
+    createdAt: string;
+}[]>;
+declare const isArtifactComponentAssociatedWithAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    artifactComponentId: string;
+}) => Promise<boolean>;
+declare const graphHasArtifactComponents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<boolean>;
+declare const countArtifactComponents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<number>;
+declare const countArtifactComponentsForAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<number>;
+/**
+ * Upsert agent-artifact component relation (create if it doesn't exist, no-op if it does)
+ */
+declare const upsertAgentArtifactComponentRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    artifactComponentId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    agentId: string;
+    artifactComponentId: string;
+} | null>;
+/**
+ * Upsert an artifact component (create if it doesn't exist, update if it does)
+ */
+declare const upsertArtifactComponent: (db: DatabaseClient) => (params: {
+    data: ArtifactComponentInsert;
+}) => Promise<ArtifactComponentSelect>;
+
+/**
+ * Get cached context data for a conversation with optional request hash validation
+ */
+declare const getCacheEntry: (db: DatabaseClient) => (params: {
+    conversationId: string;
+    contextConfigId: string;
+    contextVariableKey: string;
+    requestHash?: string;
+}) => Promise<ContextCacheSelect | null>;
+/**
+ * Set cached context data for a conversation
+ */
+declare const setCacheEntry: (db: DatabaseClient) => (entry: ContextCacheInsert) => Promise<ContextCacheSelect | null>;
+/**
+ * Clear cache entries for a specific conversation
+ */
+declare const clearConversationCache: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+}) => Promise<number>;
+/**
+ * Clear all cache entries for a specific context configuration
+ */
+declare const clearContextConfigCache: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    contextConfigId: string;
+}) => Promise<number>;
+/**
+ * Clean up all cache entries for a tenant
+ */
+declare const cleanupTenantCache: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<number>;
+/**
+ * Invalidate the request context cache for a conversation
+ */
+declare const invalidateRequestContextCache: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    contextConfigId: string;
+}) => Promise<number>;
+/**
+ * Invalidate specific cache entries for invocation-trigger definitions
+ */
+declare const invalidateInvocationDefinitionsCache: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    contextConfigId: string;
+    invocationDefinitionIds: string[];
+}) => Promise<number>;
+/**
+ * Get all cache entries for a conversation
+ */
+declare const getConversationCacheEntries: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+}) => Promise<ContextCacheSelect[]>;
+/**
+ * Get all cache entries for a context configuration
+ */
+declare const getContextConfigCacheEntries: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    contextConfigId: string;
+}) => Promise<ContextCacheSelect[]>;
+
+declare const getContextConfigById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    requestContextSchema: unknown;
+    contextVariables: Record<string, ContextFetchDefinition> | null;
+} | undefined>;
+declare const listContextConfigs: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    requestContextSchema: unknown;
+    contextVariables: Record<string, ContextFetchDefinition> | null;
+}[]>;
+declare const listContextConfigsPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: any[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const createContextConfig: (db: DatabaseClient) => (params: ContextConfigInsert) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    requestContextSchema: unknown;
+    contextVariables: Record<string, ContextFetchDefinition> | null;
+}>;
+declare const updateContextConfig: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+    data: Partial<ContextConfigUpdate>;
+}) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    requestContextSchema: unknown;
+    contextVariables: Record<string, ContextFetchDefinition> | null;
+}>;
+declare const deleteContextConfig: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<boolean>;
+declare const hasContextConfig: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<boolean>;
+declare const countContextConfigs: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<number>;
+declare const getContextConfigsByName: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    name: string;
+}) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    requestContextSchema: unknown;
+    contextVariables: Record<string, ContextFetchDefinition> | null;
+}[]>;
+/**
+ * Upsert a context config (create if it doesn't exist, update if it does)
+ */
+declare const upsertContextConfig: (db: DatabaseClient) => (params: {
+    data: ContextConfigInsert;
+}) => Promise<{
+    name: string;
+    description: string;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    requestContextSchema: unknown;
+    contextVariables: Record<string, ContextFetchDefinition> | null;
+}>;
+
+declare const listConversations: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    userId?: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    conversations: ConversationSelect[];
+    total: number;
+}>;
+declare const createConversation: (db: DatabaseClient) => (params: ConversationInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata: ConversationMetadata | null;
+    userId: string | null;
+    activeAgentId: string;
+    title: string | null;
+    lastContextResolution: string | null;
+}>;
+declare const updateConversation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    data: ConversationUpdate;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata: ConversationMetadata | null;
+    userId: string | null;
+    activeAgentId: string;
+    title: string | null;
+    lastContextResolution: string | null;
+}>;
+declare const deleteConversation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+}) => Promise<boolean>;
+declare const updateConversationActiveAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    activeAgentId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata: ConversationMetadata | null;
+    userId: string | null;
+    activeAgentId: string;
+    title: string | null;
+    lastContextResolution: string | null;
+}>;
+declare const getConversation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata: ConversationMetadata | null;
+    userId: string | null;
+    activeAgentId: string;
+    title: string | null;
+    lastContextResolution: string | null;
+} | undefined>;
+declare const createOrGetConversation: (db: DatabaseClient) => (input: ConversationInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    userId: string | null | undefined;
+    activeAgentId: string;
+    title: string | null | undefined;
+    lastContextResolution: string | null | undefined;
+    metadata: ConversationMetadata | null | undefined;
+    createdAt: string;
+    updatedAt: string;
+}>;
+/**
+ * Get conversation history with filtering and context management
+ */
+declare const getConversationHistory: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    options?: ConversationHistoryConfig;
+}) => Promise<any[]>;
+/**
+ * Get active agent for a conversation
+ */
+declare const getActiveAgentForConversation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata: ConversationMetadata | null;
+    userId: string | null;
+    activeAgentId: string;
+    title: string | null;
+    lastContextResolution: string | null;
+} | undefined>;
+/**
+ * Set active agent for a conversation (upsert operation)
+ */
+declare const setActiveAgentForConversation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    agentId: string;
+}) => Promise<void>;
+declare const setActiveAgentForThread: (db: DatabaseClient) => ({ scopes, threadId, agentId, }: {
+    scopes: ScopeConfig;
+    threadId: string;
+    agentId: string;
+}) => Promise<void>;
+
+type CredentialReferenceWithTools = CredentialReferenceSelect & {
+    tools: ToolSelect[];
+};
+/**
+ * Get a credential reference by ID
+ */
+declare const getCredentialReference: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<CredentialReferenceSelect | undefined>;
+/**
+ * Get a credential reference by ID with its related tools
+ */
+declare const getCredentialReferenceWithTools: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<CredentialReferenceWithTools | undefined>;
+/**
+ * List all credential references for a tenant/project
+ */
+declare const listCredentialReferences: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<CredentialReferenceSelect[]>;
+/**
+ * List credential references with pagination
+ */
+declare const listCredentialReferencesPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: CredentialReferenceSelect[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+/**
+ * Create a new credential reference
+ */
+declare const createCredentialReference: (db: DatabaseClient) => (params: CredentialReferenceInsert) => Promise<CredentialReferenceSelect>;
+/**
+ * Update a credential reference
+ */
+declare const updateCredentialReference: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+    data: Partial<CredentialReferenceUpdate>;
+}) => Promise<CredentialReferenceWithTools | undefined>;
+/**
+ * Delete a credential reference
+ */
+declare const deleteCredentialReference: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<boolean>;
+/**
+ * Check if a credential reference exists
+ */
+declare const hasCredentialReference: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<boolean>;
+/**
+ * Get credential reference by ID (simple version without tools)
+ */
+declare const getCredentialReferenceById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    id: string;
+}) => Promise<CredentialReferenceSelect | null>;
+/**
+ * Count credential references for a tenant/project
+ */
+declare const countCredentialReferences: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<number>;
+/**
+ * Upsert a credential reference (create if it doesn't exist, update if it does)
+ */
+declare const upsertCredentialReference: (db: DatabaseClient) => (params: {
+    data: CredentialReferenceInsert;
+}) => Promise<CredentialReferenceSelect>;
+
+/**
+ * Get a data component by ID
+ */
+declare const getDataComponent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    dataComponentId: string;
+}) => Promise<DataComponentSelect | null>;
+/**
+ * List all data components for a tenant/project
+ */
+declare const listDataComponents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<DataComponentSelect[]>;
+/**
+ * List data components with pagination
+ */
+declare const listDataComponentsPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: DataComponentSelect[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+/**
+ * Create a new data component
+ */
+declare const createDataComponent: (db: DatabaseClient) => (params: DataComponentInsert) => Promise<DataComponentSelect>;
+/**
+ * Update a data component
+ */
+declare const updateDataComponent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    dataComponentId: string;
+    data: DataComponentUpdate;
+}) => Promise<DataComponentSelect | null>;
+/**
+ * Delete a data component
+ */
+declare const deleteDataComponent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    dataComponentId: string;
+}) => Promise<boolean>;
+/**
+ * Get data components for a specific agent
+ */
+declare const getDataComponentsForAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<DataComponentSelect[]>;
+/**
+ * Associate a data component with an agent
+ */
+declare const associateDataComponentWithAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    dataComponentId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    agentId: string;
+    dataComponentId: string;
+}>;
+/**
+ * Remove association between data component and agent
+ */
+declare const removeDataComponentFromAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    dataComponentId: string;
+}) => Promise<boolean>;
+declare const deleteAgentDataComponentRelationByAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+/**
+ * Get all agents that use a specific data component
+ */
+declare const getAgentsUsingDataComponent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    dataComponentId: string;
+}) => Promise<{
+    agentId: string;
+    createdAt: string;
+}[]>;
+/**
+ * Check if a data component is associated with an agent
+ */
+declare const isDataComponentAssociatedWithAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    dataComponentId: string;
+}) => Promise<boolean>;
+/**
+ * Upsert agent-data component relation (create if it doesn't exist, no-op if it does)
+ */
+declare const upsertAgentDataComponentRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    dataComponentId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    agentId: string;
+    dataComponentId: string;
+} | null>;
+/**
+ * Count data components for a tenant/project
+ */
+declare const countDataComponents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<number>;
+/**
+ * Upsert a data component (create if it doesn't exist, update if it does)
+ */
+declare const upsertDataComponent: (db: DatabaseClient) => (params: {
+    data: DataComponentInsert;
+}) => Promise<DataComponentSelect | null>;
+
+/**
+ * Create a new external agent
+ */
+declare const createExternalAgent: (db: DatabaseClient) => (params: ExternalAgentInsert) => Promise<ExternalAgentSelect>;
+/**
+ * Get external agent by ID
+ */
+declare const getExternalAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<ExternalAgentSelect | null>;
+/**
+ * Get external agent by base URL
+ */
+declare const getExternalAgentByUrl: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    baseUrl: string;
+}) => Promise<ExternalAgentSelect | null>;
+/**
+ * List external agents for a tenant
+ */
+declare const listExternalAgents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<ExternalAgentSelect[]>;
+/**
+ * List external agents with pagination
+ */
+declare const listExternalAgentsPaginated: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: ExternalAgentSelect[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+/**
+ * Update an existing external agent
+ */
+declare const updateExternalAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    data: Partial<ExternalAgentUpdate>;
+}) => Promise<ExternalAgentSelect | null>;
+/**
+ * Upsert external agent (create if it doesn't exist, update if it does)
+ */
+declare const upsertExternalAgent: (db: DatabaseClient) => (params: {
+    data: ExternalAgentInsert;
+}) => Promise<ExternalAgentSelect>;
+/**
+ * Delete an external agent
+ */
+declare const deleteExternalAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+/**
+ * Check if an external agent exists
+ */
+declare const externalAgentExists: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<boolean>;
+/**
+ * Check if an external agent exists by URL
+ */
+declare const externalAgentUrlExists: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    baseUrl: string;
+}) => Promise<boolean>;
+/**
+ * Count external agents for a tenant
+ */
+declare const countExternalAgents: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<number>;
+
+interface GraphLogger {
+    info(obj: Record<string, any>, msg?: string): void;
+    error(obj: Record<string, any>, msg?: string): void;
+}
+/**
+ * Server-side implementation of createFullGraph that performs actual database operations.
+ * This function creates a complete graph with all agents, tools, and relationships.
+ */
+declare const createFullGraphServerSide: (db: DatabaseClient, logger?: GraphLogger) => (scopes: ScopeConfig, graphData: FullGraphDefinition) => Promise<FullGraphDefinition>;
+/**
+ * Server-side implementation of updateFullGraph that performs actual database operations.
+ * This function updates a complete graph with all agents, tools, and relationships.
+ */
+declare const updateFullGraphServerSide: (db: DatabaseClient, logger?: GraphLogger) => (scopes: ScopeConfig, graphData: FullGraphDefinition) => Promise<FullGraphDefinition>;
+/**
+ * Get a complete graph definition by ID
+ */
+declare const getFullGraph: (db: DatabaseClient, logger?: GraphLogger) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<FullGraphDefinition | null>;
+/**
+ * Delete a complete graph and cascade to all related entities
+ */
+declare const deleteFullGraph: (db: DatabaseClient, logger?: GraphLogger) => (params: {
+    scopes: ScopeConfig;
+    graphId: string;
+}) => Promise<boolean>;
+
+/**
+ * Save one or more artifacts to the ledger
+ */
+declare const addLedgerArtifacts: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    contextId: string;
+    taskId?: string | null;
+    artifacts: Artifact[];
+}) => Promise<void>;
+/**
+ * Retrieve artifacts by taskId and/or artifactId.
+ * At least one of taskId or artifactId must be provided.
+ */
+declare const getLedgerArtifacts: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    taskId?: string;
+    artifactId?: string;
+}) => Promise<Artifact[]>;
+/**
+ * Get ledger artifacts by context ID
+ */
+declare const getLedgerArtifactsByContext: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    contextId: string;
+}) => Promise<LedgerArtifactSelect[]>;
+/**
+ * Delete ledger artifacts by task ID
+ */
+declare const deleteLedgerArtifactsByTask: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    taskId: string;
+}) => Promise<boolean>;
+/**
+ * Delete ledger artifacts by context ID
+ */
+declare const deleteLedgerArtifactsByContext: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    contextId: string;
+}) => Promise<boolean>;
+/**
+ * Count ledger artifacts by task ID
+ */
+declare const countLedgerArtifactsByTask: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    taskId: string;
+}) => Promise<number>;
+
+declare const getMessageById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    messageId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    conversationId: string;
+    metadata: MessageMetadata | null;
+    agentId: string | null;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+} | undefined>;
+declare const listMessages: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination: PaginationConfig;
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    conversationId: string;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    agentId: string | null;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+    metadata: MessageMetadata | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const getMessagesByConversation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    pagination: PaginationConfig;
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    conversationId: string;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    agentId: string | null;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+    metadata: MessageMetadata | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const getMessagesByTask: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    taskId: string;
+    pagination: PaginationConfig;
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    conversationId: string;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    agentId: string | null;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+    metadata: MessageMetadata | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const getVisibleMessages: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+    visibility?: MessageVisibility[];
+    pagination: PaginationConfig;
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    conversationId: string;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    agentId: string | null;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+    metadata: MessageMetadata | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const createMessage: (db: DatabaseClient) => (params: MessageInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    conversationId: string;
+    metadata: MessageMetadata | null;
+    agentId: string | null;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+}>;
+declare const updateMessage: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    messageId: string;
+    data: MessageUpdate;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    conversationId: string;
+    metadata: MessageMetadata | null;
+    agentId: string | null;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+}>;
+declare const deleteMessage: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    messageId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    conversationId: string;
+    metadata: MessageMetadata | null;
+    agentId: string | null;
+    role: string;
+    fromAgentId: string | null;
+    toAgentId: string | null;
+    fromExternalAgentId: string | null;
+    toExternalAgentId: string | null;
+    content: MessageContent;
+    visibility: string;
+    messageType: string;
+    taskId: string | null;
+    parentMessageId: string | null;
+    a2aTaskId: string | null;
+    a2aSessionId: string | null;
+}>;
+declare const countMessagesByConversation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    conversationId: string;
+}) => Promise<number>;
+
+/**
+ * List all unique project IDs within a tenant by scanning all resource tables
+ */
+declare const listProjects: (db: DatabaseClient) => (params: {
+    tenantId: string;
+}) => Promise<ProjectInfo[]>;
+/**
+ * List all unique project IDs within a tenant with pagination
+ */
+declare const listProjectsPaginated: (db: DatabaseClient) => (params: {
+    tenantId: string;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: ProjectSelect[];
+    pagination: PaginationResult;
+}>;
+/**
+ * Get resource counts for a specific project
+ */
+declare const getProjectResourceCounts: (db: DatabaseClient) => (params: ScopeConfig) => Promise<ProjectResourceCounts>;
+/**
+ * Check if a project exists (has any resources)
+ */
+declare const projectExists: (db: DatabaseClient) => (params: ScopeConfig) => Promise<boolean>;
+/**
+ * Count total projects for a tenant
+ */
+declare const countProjects: (db: DatabaseClient) => (params: {
+    tenantId: string;
+}) => Promise<number>;
+/**
+ * Get a single project by ID
+ */
+declare const getProject: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<ProjectSelect | null>;
+/**
+ * Create a new project
+ */
+declare const createProject: (db: DatabaseClient) => (params: ProjectInsert) => Promise<ProjectSelect>;
+/**
+ * Update an existing project
+ */
+declare const updateProject: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    data: ProjectUpdate;
+}) => Promise<ProjectSelect | null>;
+/**
+ * Check if a project exists in the projects table
+ */
+declare const projectExistsInTable: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<boolean>;
+/**
+ * Check if a project has any resources (used before deletion)
+ */
+declare const projectHasResources: (db: DatabaseClient) => (params: ScopeConfig) => Promise<boolean>;
+/**
+ * Delete a project (with validation for existing resources)
+ */
+declare const deleteProject: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+}) => Promise<boolean>;
+
+declare const createTask: (db: DatabaseClient) => (params: TaskInsert) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    contextId: string;
+    status: string;
+    metadata: TaskMetadataConfig | null;
+    agentId: string;
+}>;
+declare const getTask: (db: DatabaseClient) => (params: {
+    id: string;
+}) => Promise<TaskSelect | null>;
+declare const updateTask: (db: DatabaseClient) => (params: {
+    taskId: string;
+    data: {
+        status?: string;
+        metadata?: any;
+    };
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    contextId: string;
+    status: string;
+    metadata: TaskMetadataConfig | null;
+    agentId: string;
+}>;
+declare const listTaskIdsByContextId: (db: DatabaseClient) => (params: {
+    contextId: string;
+}) => Promise<string[]>;
+
+declare const dbResultToMcpTool: (dbResult: ToolSelect) => McpTool;
+declare const getToolById: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    toolId: string;
+}) => Promise<{
+    name: string;
+    headers: Record<string, string> | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    credentialReferenceId: string | null;
+    status: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+} | null>;
+declare const listTools: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    pagination?: PaginationConfig;
+}) => Promise<{
+    data: {
+        tenantId: string;
+        projectId: string;
+        id: string;
+        name: string;
+        config: {
+            type: "mcp";
+            mcp: ToolMcpConfig;
+        };
+        credentialReferenceId: string | null;
+        headers: Record<string, string> | null;
+        imageUrl: string | null;
+        capabilities: ToolServerCapabilities | null;
+        status: string;
+        lastHealthCheck: string | null;
+        lastError: string | null;
+        availableTools: McpToolDefinition[] | null;
+        lastToolsSync: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>;
+declare const getToolsByStatus: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    status: string;
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    name: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    credentialReferenceId: string | null;
+    headers: Record<string, string> | null;
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    status: string;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+declare const listToolsByStatus: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    status: McpToolStatus;
+}) => Promise<{
+    name: string;
+    headers: Record<string, string> | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    credentialReferenceId: string | null;
+    status: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+}[]>;
+declare const createTool: (db: DatabaseClient) => (params: ToolInsert) => Promise<{
+    name: string;
+    headers: Record<string, string> | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    credentialReferenceId: string | null;
+    status: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+}>;
+declare const updateTool: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    toolId: string;
+    data: ToolUpdate;
+}) => Promise<{
+    name: string;
+    headers: Record<string, string> | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    credentialReferenceId: string | null;
+    status: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+}>;
+declare const deleteTool: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    toolId: string;
+}) => Promise<boolean>;
+declare const addToolToAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    toolId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    agentId: string;
+    toolId: string;
+}>;
+declare const removeToolFromAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    toolId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    agentId: string;
+    toolId: string;
+}>;
+/**
+ * Upsert agent-tool relation (create if it doesn't exist, no-op if it does)
+ */
+declare const upsertAgentToolRelation: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+    toolId: string;
+}) => Promise<{
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    agentId: string;
+    toolId: string;
+}>;
+declare const updateToolStatus: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    toolId: string;
+    status: string;
+    lastHealthCheck?: string;
+    lastError?: string;
+}) => Promise<{
+    name: string;
+    headers: Record<string, string> | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    credentialReferenceId: string | null;
+    status: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+}>;
+/**
+ * Upsert a tool (create if it doesn't exist, update if it does)
+ */
+declare const upsertTool: (db: DatabaseClient) => (params: {
+    data: ToolInsert;
+}) => Promise<{
+    name: string;
+    headers: Record<string, string> | null;
+    id: string;
+    tenantId: string;
+    projectId: string;
+    createdAt: string;
+    updatedAt: string;
+    credentialReferenceId: string | null;
+    status: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+}>;
+declare const getHealthyToolsForAgent: (db: DatabaseClient) => (params: {
+    scopes: ScopeConfig;
+    agentId: string;
+}) => Promise<{
+    tenantId: string;
+    projectId: string;
+    id: string;
+    name: string;
+    config: {
+        type: "mcp";
+        mcp: ToolMcpConfig;
+    };
+    credentialReferenceId: string | null;
+    headers: Record<string, string> | null;
+    imageUrl: string | null;
+    capabilities: ToolServerCapabilities | null;
+    status: string;
+    lastHealthCheck: string | null;
+    lastError: string | null;
+    availableTools: McpToolDefinition[] | null;
+    lastToolsSync: string | null;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+
+/**
+ * Validates that a project exists before performing database operations
+ * This provides runtime validation even when foreign key constraints are not enforced
+ */
+declare const validateProjectExists: (db: DatabaseClient, tenantId: string, projectId: string) => Promise<void>;
+/**
+ * Wraps a database operation with project validation
+ * Ensures the project exists before executing the operation
+ */
+declare const withProjectValidation: <T extends (...args: any[]) => Promise<any>>(db: DatabaseClient, operation: T) => (params: Parameters<T>[0]) => Promise<ReturnType<T>>;
+/**
+ * Creates a validated version of data access functions
+ * Automatically adds project validation to insert/update operations
+ */
+declare const createValidatedDataAccess: <T extends Record<string, any>>(db: DatabaseClient, dataAccessFunctions: T) => T;
+
+declare const HTTP_REQUEST_PARTS: readonly ["body", "headers", "query", "params"];
+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 {
+    body?: any;
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    params?: 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;
+/**
+ * Checks if the schema is in the new comprehensive request format
+ */
+declare function isComprehensiveRequestSchema(schema: any): boolean;
+/**
+ * Validates HTTP request parts against comprehensive schema
+ */
+declare function validateHttpRequestParts(comprehensiveSchema: any, httpRequest: ParsedHttpRequest): Promise<ContextValidationResult>;
+/**
+ * Validates request context against the JSON Schema stored in context configuration
+ * Supports both legacy simple schemas and new comprehensive HTTP request schemas
+ */
+declare function validateRequestContext(tenantId: string, projectId: string, graphId: string, conversationId: string, parsedRequest: ParsedHttpRequest, dbClient: DatabaseClient, credentialStores?: CredentialStoreRegistry, legacyRequestContext?: Record<string, unknown>): Promise<ContextValidationResult>;
+/**
+ * Hono middleware for context validation
+ */
+declare function contextValidationMiddleware(dbClient: DatabaseClient): (c: Context, next: Next) => Promise<void | (Response & hono.TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & hono.TypedResponse<{
+    error: string;
+    message: string;
+}, 500, "json">)>;
+
+type ApiKeyGenerationResult = {
+    id: string;
+    publicId: string;
+    key: string;
+    keyHash: string;
+    keyPrefix: string;
+};
+/**
+ * Generate a new API key with secure random bytes
+ */
+declare function generateApiKey(): Promise<ApiKeyGenerationResult>;
+/**
+ * Hash an API key using scrypt
+ */
+declare function hashApiKey(key: string): Promise<string>;
+/**
+ * Validate an API key against its hash
+ */
+declare function validateApiKey(key: string, storedHash: string): Promise<boolean>;
+/**
+ * Check if an API key has expired
+ */
+declare function isApiKeyExpired(expiresAt?: string | null): boolean;
+/**
+ * Extract the publicId from an API key
+ */
+declare function extractPublicId(key: string): string | null;
+/**
+ * Mask an API key for display (show only prefix and last 4 chars)
+ */
+declare function maskApiKey(keyPrefix: string): string;
+
+/**
+ * Logger factory for core utilities package
+ * Designed to work with Pino-style loggers and request context
+ */
+interface Logger {
+    debug: (obj: any, msg?: string) => void;
+    info: (obj: any, msg?: string) => void;
+    warn: (obj: any, msg?: string) => void;
+    error: (obj: any, msg?: string) => void;
+}
+
+/**
+ * Centralized authentication detection utilities for MCP tools
+ */
+
+/**
+ * OAuth configuration interface
+ */
+interface OAuthConfig {
+    authorizationUrl: string;
+    tokenUrl: string;
+    registrationUrl?: string;
+    supportsDynamicRegistration: boolean;
+}
+/**
+ * Full OAuth endpoint discovery with complete configuration
+ */
+declare const discoverOAuthEndpoints: (serverUrl: string, logger?: Logger) => Promise<OAuthConfig | null>;
+/**
+ * Detect if OAuth 2.1/PKCE authentication is specifically required for a tool
+ */
+declare const detectAuthenticationRequired: (tool: McpTool, error: Error, logger?: Logger) => Promise<boolean>;
+
+/**
+ * Get a lookup key for a credential store from retrieval params
+ * @param retrievalParams - The retrieval params for the credential store
+ * @param credentialStoreType - The type of credential store
+ * @returns A lookup key for the credential store, used to call <CredentialStore>.get()
+ */
+declare function getCredentialStoreLookupKeyFromRetrievalParams({ retrievalParams, credentialStoreType, }: {
+    retrievalParams: Record<string, unknown>;
+    credentialStoreType: string;
+}): string | null;
+
+declare const ErrorCode: z$1.ZodEnum<{
+    unauthorized: "unauthorized";
+    bad_request: "bad_request";
+    forbidden: "forbidden";
+    not_found: "not_found";
+    conflict: "conflict";
+    internal_server_error: "internal_server_error";
+    unprocessable_entity: "unprocessable_entity";
+}>;
+declare const ERROR_DOCS_BASE_URL = "https://docs.inkeep.com/agents-api/errors";
+declare const problemDetailsSchema: z$1.ZodObject<{
+    title: z$1.ZodString;
+    status: z$1.ZodNumber;
+    detail: z$1.ZodString;
+    instance: z$1.ZodOptional<z$1.ZodString>;
+    requestId: z$1.ZodOptional<z$1.ZodString>;
+    code: z$1.ZodEnum<{
+        unauthorized: "unauthorized";
+        bad_request: "bad_request";
+        forbidden: "forbidden";
+        not_found: "not_found";
+        conflict: "conflict";
+        internal_server_error: "internal_server_error";
+        unprocessable_entity: "unprocessable_entity";
+    }>;
+}, z$1.core.$strip>;
+type ProblemDetails = z$1.infer<typeof problemDetailsSchema>;
+type ErrorCodes = z$1.infer<typeof ErrorCode>;
+declare const errorResponseSchema: z$1.ZodObject<{
+    error: z$1.ZodObject<{
+        code: z$1.ZodEnum<{
+            unauthorized: "unauthorized";
+            bad_request: "bad_request";
+            forbidden: "forbidden";
+            not_found: "not_found";
+            conflict: "conflict";
+            internal_server_error: "internal_server_error";
+            unprocessable_entity: "unprocessable_entity";
+        }>;
+        message: z$1.ZodString;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>;
+type ErrorResponse = z$1.infer<typeof errorResponseSchema>;
+declare function createApiError({ code, message, instance, requestId, }: {
+    code: ErrorCodes;
+    message: string;
+    instance?: string;
+    requestId?: string;
+}): HTTPException;
+declare function handleApiError(error: unknown, requestId?: string): Promise<ProblemDetails & {
+    error: {
+        code: ErrorCodes;
+        message: string;
+    };
+}>;
+declare const errorSchemaFactory: (code: ErrorCodes, description: string) => {
+    description: string;
+    content: {
+        'application/problem+json': {
+            schema: z$1.ZodObject<{
+                instance: z$1.ZodOptional<z$1.ZodString>;
+                requestId: z$1.ZodOptional<z$1.ZodString>;
+                code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                detail: z$1.ZodString;
+                title: z$1.ZodString;
+                status: z$1.ZodLiteral<number>;
+                error: z$1.ZodObject<{
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    message: z$1.ZodString;
+                }, z$1.core.$strip>;
+            }, z$1.core.$strip>;
+        };
+    };
+};
+declare const commonCreateErrorResponses: {
+    readonly 400: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 401: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 403: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 422: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 500: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+};
+declare const commonUpdateErrorResponses: {
+    readonly 400: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 401: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 403: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 404: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 422: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 500: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+};
+declare const commonGetErrorResponses: {
+    readonly 400: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 401: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 403: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 404: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 422: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 500: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+};
+declare const commonDeleteErrorResponses: {
+    readonly 400: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 401: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 403: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 404: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 422: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+    readonly 500: {
+        description: string;
+        content: {
+            'application/problem+json': {
+                schema: z$1.ZodObject<{
+                    instance: z$1.ZodOptional<z$1.ZodString>;
+                    requestId: z$1.ZodOptional<z$1.ZodString>;
+                    code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                    detail: z$1.ZodString;
+                    title: z$1.ZodString;
+                    status: z$1.ZodLiteral<number>;
+                    error: z$1.ZodObject<{
+                        code: z$1.ZodLiteral<"unauthorized" | "bad_request" | "forbidden" | "not_found" | "conflict" | "internal_server_error" | "unprocessable_entity">;
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+            };
+        };
+    };
+};
+type CommonCreateErrorResponses = typeof commonCreateErrorResponses;
+type CommonUpdateErrorResponses = typeof commonUpdateErrorResponses;
+type CommonGetErrorResponses = typeof commonGetErrorResponses;
+type CommonDeleteErrorResponses = typeof commonDeleteErrorResponses;
+
+/**
+ * Create execution context from middleware values
+ */
+declare function createExecutionContext(params: {
+    apiKey: string;
+    tenantId: string;
+    projectId: string;
+    graphId: string;
+    apiKeyId: string;
+    baseUrl?: string;
+}): ExecutionContext;
+/**
+ * Get execution context from API key authentication
+ */
+declare function getRequestExecutionContext(c: Context): ExecutionContext;
+
+declare const BASE = "inkeep-chat";
+declare const SERVICE_NAME = "inkeep-chat";
+declare const SERVICE_VERSION = "1.0.0";
+declare const createSpanName: (suffix: string) => string;
+/**
+ * Helper function to handle span errors consistently
+ * Records the exception, sets error status, and optionally logs
+ */
+declare function handleSpanError(span: Span, error: unknown, logger?: {
+    error: (obj: any, msg?: string) => void;
+}, logMessage?: string): void;
+/**
+ * Get the global tracer instance
+ * This creates a single tracer for the entire application
+ */
+declare function getGlobalTracer(): Tracer;
+/**
+ * Force flush the tracer provider to ensure critical spans are sent immediately
+ * This is useful for critical operations where we want to ensure telemetry data
+ * is sent before the operation completes or fails
+ */
+declare function forceFlushTracer(): Promise<void>;
+
+export { AgentGraphInsert, AgentGraphUpdate, AgentInsert, AgentRelationInsert, AgentRelationUpdate, AgentSelect, AgentToolRelationUpdate, AgentUpdate, ApiKeyCreateResult, type ApiKeyGenerationResult, ApiKeyInsert, ApiKeySelect, ApiKeyUpdate, Artifact, ArtifactComponentInsert, ArtifactComponentSelect, ArtifactComponentUpdate, BASE, type CommonCreateErrorResponses, type CommonDeleteErrorResponses, type CommonGetErrorResponses, type CommonUpdateErrorResponses, ConsoleLogger, ContextCache, ContextCacheInsert, ContextCacheSelect, ContextConfigBuilder, type ContextConfigBuilderOptions, ContextConfigInsert, ContextConfigSelect, ContextConfigUpdate, ContextFetchDefinition, ContextFetcher, type ContextResolutionOptions, type ContextResolutionResult, ContextResolver, type ContextResolverInterface, type ContextValidationError, type ContextValidationResult, ConversationHistoryConfig, ConversationInsert, ConversationMetadata, ConversationSelect, ConversationUpdate, CreateApiKeyParams, type CredentialContext, type CredentialData, CredentialReferenceInsert, CredentialReferenceSelect, CredentialReferenceUpdate, type CredentialReferenceWithTools, type CredentialResolverInput, CredentialStore, type CredentialStoreReference, CredentialStoreRegistry, CredentialStuffer, DataComponentInsert, DataComponentSelect, DataComponentUpdate, type DatabaseClient, type DatabaseConfig, ERROR_DOCS_BASE_URL, ErrorCode, type ErrorCodes, type ErrorResponse, ExecutionContext, ExternalAgentInsert, ExternalAgentRelationInsert, ExternalAgentSelect, ExternalAgentUpdate, FetchDefinition, type FetchResult, FullGraphDefinition, type GraphLogger, HTTP_REQUEST_PARTS, type HttpRequestPart, InMemoryCredentialStore, KeyChainStore, LedgerArtifactSelect, type Logger$1 as Logger, type LoggerFactoryConfig, MCPToolConfig, McpClient, type McpClientOptions, type McpSSEConfig, type McpServerConfig, type McpStreamableHttpConfig, McpTool, McpToolDefinition, McpToolStatus, MessageContent, MessageInsert, MessageMetadata, MessageUpdate, MessageVisibility, NangoCredentialStore, NoOpLogger, type OAuthConfig, PaginationConfig, PaginationResult, type ParsedHttpRequest, type ProblemDetails, ProjectInfo, ProjectInsert, ProjectResourceCounts, ProjectSelect, ProjectUpdate, RequestSchemaConfig, RequestSchemaDefinition, type ResolvedContext, SERVICE_NAME, SERVICE_VERSION, ScopeConfig, TaskInsert, TaskMetadataConfig, TaskSelect, type TemplateContext, TemplateEngine, type TemplateRenderOptions, ToolInsert, ToolMcpConfig, ToolSelect, ToolServerCapabilities, ToolUpdate, addLedgerArtifacts, addToolToAgent, associateArtifactComponentWithAgent, associateDataComponentWithAgent, cleanupTenantCache, clearContextConfigCache, clearConversationCache, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, configureLogging, contextConfig, contextValidationMiddleware, countApiKeys, countArtifactComponents, countArtifactComponentsForAgent, countContextConfigs, countCredentialReferences, countDataComponents, countExternalAgents, countLedgerArtifactsByTask, countMessagesByConversation, countProjects, createAgent, createAgentGraph, createAgentRelation, createAgentToolRelation, createApiError, createApiKey, createArtifactComponent, createContextConfig, createConversation, createCredentialReference, createDataComponent, createDatabaseClient, createDefaultCredentialStores, createExecutionContext, createExternalAgent, createExternalAgentRelation, createFullGraphServerSide, createInMemoryDatabaseClient, createKeyChainStore, createMessage, createNangoCredentialStore, createOrGetConversation, createProject, createRequestSchema, createSpanName, createTask, createTool, createValidatedDataAccess, dbResultToMcpTool, deleteAgent, deleteAgentArtifactComponentRelationByAgent, deleteAgentDataComponentRelationByAgent, deleteAgentGraph, deleteAgentRelation, deleteAgentRelationsByGraph, deleteAgentToolRelation, deleteAgentToolRelationByAgent, deleteApiKey, deleteArtifactComponent, deleteContextConfig, deleteConversation, deleteCredentialReference, deleteDataComponent, deleteExternalAgent, deleteFullGraph, deleteLedgerArtifactsByContext, deleteLedgerArtifactsByTask, deleteMessage, deleteProject, deleteTool, detectAuthenticationRequired, determineContextTrigger, discoverOAuthEndpoints, errorResponseSchema, errorSchemaFactory, externalAgentExists, externalAgentUrlExists, extractPublicId, fetchComponentRelationships, fetchDefinition, forceFlushTracer, generateAndCreateApiKey, generateApiKey, getActiveAgentForConversation, getAgentById, getAgentGraph, getAgentGraphById, getAgentGraphWithDefaultAgent, getAgentInGraphContext, getAgentRelationById, getAgentRelationByParams, getAgentRelations, getAgentRelationsByGraph, getAgentRelationsBySource, getAgentRelationsByTarget, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentsByIds, getAgentsForTool, getAgentsUsingArtifactComponent, getAgentsUsingDataComponent, getApiKeyById, getApiKeyByPublicId, getArtifactComponentById, getArtifactComponentsForAgent, getCacheEntry, getCachedValidator, getContextConfigById, getContextConfigCacheEntries, getContextConfigsByName, getConversation, getConversationCacheEntries, getConversationHistory, getCredentialReference, getCredentialReferenceById, getCredentialReferenceWithTools, getCredentialStoreLookupKeyFromRetrievalParams, getDataComponent, getDataComponentsForAgent, getExternalAgent, getExternalAgentByUrl, getExternalAgentRelations, getFullGraph, getFullGraphDefinition, getGlobalTracer, getGraphAgentInfos, getHealthyToolsForAgent, getLedgerArtifacts, getLedgerArtifactsByContext, getLogger, getMessageById, getMessagesByConversation, getMessagesByTask, getProject, getProjectResourceCounts, getRelatedAgentsForGraph, getRequestExecutionContext, getTask, getToolById, getToolsByStatus, getToolsForAgent, getVisibleMessages, graphHasArtifactComponents, handleApiError, handleContextConfigChange, handleContextResolution, handleSpanError, hasApiKey, hasContextConfig, hasCredentialReference, hashApiKey, invalidateInvocationDefinitionsCache, invalidateRequestContextCache, isApiKeyExpired, isArtifactComponentAssociatedWithAgent, isComprehensiveRequestSchema, isDataComponentAssociatedWithAgent, isValidHttpRequest, listAgentGraphs, listAgentGraphsPaginated, listAgentRelations, listAgentToolRelations, listAgentToolRelationsByAgent, listAgents, listAgentsPaginated, listApiKeys, listApiKeysPaginated, listArtifactComponents, listArtifactComponentsPaginated, listContextConfigs, listContextConfigsPaginated, listConversations, listCredentialReferences, listCredentialReferencesPaginated, listDataComponents, listDataComponentsPaginated, listExternalAgents, listExternalAgentsPaginated, listMessages, listProjects, listProjectsPaginated, listTaskIdsByContextId, listTools, listToolsByStatus, loggerFactory, maskApiKey, problemDetailsSchema, projectExists, projectExistsInTable, projectHasResources, removeArtifactComponentFromAgent, removeDataComponentFromAgent, removeToolFromAgent, setActiveAgentForConversation, setActiveAgentForThread, setCacheEntry, updateAgent, updateAgentGraph, updateAgentRelation, updateAgentToolRelation, updateApiKey, updateApiKeyLastUsed, updateArtifactComponent, updateContextConfig, updateConversation, updateConversationActiveAgent, updateCredentialReference, updateDataComponent, updateExternalAgent, updateFullGraphServerSide, updateMessage, updateProject, updateTask, updateTool, updateToolStatus, upsertAgent, upsertAgentArtifactComponentRelation, upsertAgentDataComponentRelation, upsertAgentGraph, upsertAgentRelation, upsertAgentToolRelation, upsertArtifactComponent, upsertContextConfig, upsertCredentialReference, upsertDataComponent, upsertExternalAgent, upsertTool, validateAgainstJsonSchema, validateAndGetApiKey, validateApiKey, validateExternalAgent, validateHttpRequestParts, validateInternalAgent, validateProjectExists, validateRequestContext, validationHelper, withProjectValidation };