@agentronics/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2 @@
+import {f,d,P}from'./chunk-DKDVADEU.js';export{E as DEFAULT_GROUP,w as WELL_KNOWN_PATH,b as bundledDetectors,k as createAgentContextStore,j as createAuthEngine,M as createConsoleExporter,c as createDetectorRegistry,N as createGatewayExporter,g as createIdentityStore,s as createMemoryCache,q as createMemoryStore,n as createPolicyCache,m as createPolicyEngine,A as createProgressionStore,l as createRateLimiter,e as createSignatureLoader,r as createSiteMemoryStore,z as createToolRegistry,K as createTraceBuffer,L as createTracer,J as createWebMcpAdapter,t as createWebMcpContextTool,O as createWebhookExporter,B as decideSurfacing,d as declareAgent,h as deriveTrustLevel,f as detectAgent,a as detectDom,I as estimateBudget,H as estimateToolTokens,D as explainSurfacing,x as fetchWellKnownContext,F as groupTools,i as highestTrust,P as init,p as installDomEnforcer,v as installMemoryOverlay,u as installMetaTags,G as listGroupNames,y as serializeWellKnownContext,o as showDenyOverlay,C as surfaceTools}from'./chunk-DKDVADEU.js';export{a as detectWebMcp}from'./chunk-5BS4OAQA.js';var me={init:P,declareAgent:d,detectAgent:f},ge="0.1.0";export{me as Agentronics,ge as VERSION};//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["Agentronics","init","declareAgent","detectAgent","VERSION"],"mappings":"ujCAmMO,IAAMA,EAAAA,CAAc,CAAE,IAAA,CAAAC,CAAAA,CAAM,aAAAC,CAAAA,CAAc,WAAA,CAAAC,CAAY,CAAA,CAEhDC,EAAAA,CAAU","file":"index.js","sourcesContent":["import { init, type AgentronicsClient, type InitOptions } from './init.js'\nimport {\n  declareAgent,\n  bundledDetectors,\n  createDetectorRegistry,\n  createSignatureLoader,\n  detectAgent,\n  detectDom,\n  detectWebMcp,\n  type DeclareAgentInput,\n  type DetectAgentOptions,\n  type DetectDomOptions,\n  type DetectWebMcpOptions,\n  type Detector,\n  type DetectorRegistry,\n  type DetectorStatus,\n  type DomSignalName,\n} from './detection/index.js'\nimport {\n  createIdentityStore,\n  type IdentityStore,\n  type PresentIdentityOptions,\n  type PresentedIdentity,\n} from './auth/identity.js'\nimport { createAuthEngine, type AuthEngine, type AuthInput, type AuthMethod } from './auth/engine.js'\nimport {\n  createAgentContextStore,\n  type AgentContextStore,\n  type AgentContextSnapshot,\n  type AgentContextListener,\n} from './auth/agentContext.js'\nimport { deriveTrustLevel, highestTrust } from './auth/trustLevel.js'\nimport { createPolicyEngine, type PolicyEngine } from './authz/engine.js'\nimport { createRateLimiter, type RateLimiter } from './authz/rateLimiter.js'\nimport { createPolicyCache, type PolicyCache } from './authz/policyCache.js'\nimport { installDomEnforcer } from './authz/domEnforcer.js'\nimport { showDenyOverlay } from './authz/overlay.js'\nimport { createMemoryStore, type MemoryStore } from './memory/store.js'\nimport {\n  createSiteMemoryStore,\n  type SiteMemoryStore,\n  type SiteMemoryListener,\n  type ProvideForPageInput,\n} from './memory/siteMemory.js'\nimport { createMemoryCache, type MemoryCache } from './memory/memoryCache.js'\nimport {\n  createWebMcpContextTool,\n  installMetaTags,\n  installMemoryOverlay,\n  fetchWellKnownContext,\n  serializeWellKnownContext,\n  WELL_KNOWN_PATH,\n  type WebMcpContextTool,\n  type WebMcpContextOptions,\n} from './memory/delivery/index.js'\nimport { createToolRegistry, type GovernedTool, type ToolRegistry } from './tools/registry.js'\nimport {\n  decideSurfacing,\n  surfaceTools,\n  explainSurfacing,\n  type SurfacingContext,\n  type SurfacingDecision,\n} from './tools/surfacing.js'\nimport {\n  groupTools,\n  listGroupNames,\n  DEFAULT_GROUP,\n  type ToolGroupSummary,\n} from './tools/groups.js'\nimport {\n  createProgressionStore,\n  type ProgressionConfig,\n  type ProgressionStage,\n  type ProgressionStore,\n  type ProgressionTransition,\n} from './tools/progression.js'\nimport {\n  estimateBudget,\n  estimateToolTokens,\n  type ToolTokenEstimate,\n  type TokenBudgetReport,\n} from './tools/tokenEstimate.js'\nimport {\n  createWebMcpAdapter,\n  type WebMcpAdapter,\n  type WebMcpAdapterOptions,\n  type WebMcpToolDescriptor,\n  type WebMcpProvider,\n} from './tools/webmcpAdapter.js'\nimport {\n  createTracer,\n  createTraceBuffer,\n  createConsoleExporter,\n  createGatewayExporter,\n  createWebhookExporter,\n  type TraceExporter,\n  type TraceInput,\n  type Tracer,\n} from './observability/index.js'\n\nexport {\n  init,\n  declareAgent,\n  detectAgent,\n  detectDom,\n  detectWebMcp,\n  createDetectorRegistry,\n  bundledDetectors,\n  createSignatureLoader,\n  createIdentityStore,\n  createAuthEngine,\n  createAgentContextStore,\n  deriveTrustLevel,\n  highestTrust,\n  createPolicyEngine,\n  createRateLimiter,\n  createPolicyCache,\n  installDomEnforcer,\n  showDenyOverlay,\n  createToolRegistry,\n  decideSurfacing,\n  surfaceTools,\n  explainSurfacing,\n  groupTools,\n  listGroupNames,\n  DEFAULT_GROUP,\n  createProgressionStore,\n  estimateBudget,\n  estimateToolTokens,\n  createWebMcpAdapter,\n  createMemoryStore,\n  createSiteMemoryStore,\n  createMemoryCache,\n  createWebMcpContextTool,\n  installMetaTags,\n  installMemoryOverlay,\n  fetchWellKnownContext,\n  serializeWellKnownContext,\n  WELL_KNOWN_PATH,\n  createTracer,\n  createTraceBuffer,\n  createConsoleExporter,\n  createGatewayExporter,\n  createWebhookExporter,\n}\nexport type {\n  AgentronicsClient,\n  AuthEngine,\n  AuthInput,\n  AuthMethod,\n  AgentContextStore,\n  AgentContextSnapshot,\n  AgentContextListener,\n  DeclareAgentInput,\n  DetectAgentOptions,\n  DetectDomOptions,\n  DetectWebMcpOptions,\n  DomSignalName,\n  IdentityStore,\n  InitOptions,\n  MemoryStore,\n  SiteMemoryStore,\n  SiteMemoryListener,\n  MemoryCache,\n  ProvideForPageInput,\n  WebMcpContextTool,\n  WebMcpContextOptions,\n  GovernedTool,\n  ToolRegistry,\n  SurfacingContext,\n  SurfacingDecision,\n  ToolGroupSummary,\n  ProgressionConfig,\n  ProgressionStage,\n  ProgressionStore,\n  ProgressionTransition,\n  ToolTokenEstimate,\n  TokenBudgetReport,\n  WebMcpAdapter,\n  WebMcpAdapterOptions,\n  WebMcpToolDescriptor,\n  WebMcpProvider,\n  PolicyEngine,\n  PolicyCache,\n  RateLimiter,\n  Detector,\n  DetectorRegistry,\n  DetectorStatus,\n  PresentIdentityOptions,\n  PresentedIdentity,\n  TraceExporter,\n  TraceInput,\n  Tracer,\n}\n\nexport const Agentronics = { init, declareAgent, detectAgent }\n\nexport const VERSION = '0.1.0'\n"]}

package/dist/init-only-6SWFNqud.d.cts

@@ -0,0 +1,508 @@
+import { AgentIdentity, IdentityClaim, TraceEvent, TraceEventType, VerificationResult, AgentClass, PolicyRule, PolicyEvaluation, MemoryScope, MemoryEntry, SiteMemory, SiteMemoryPageContext } from '@agentronics/protocol';
+import { D as DetectWebMcpOptions } from './webmcp-C4ikhM4g.cjs';
+
+interface SignalResult {
+    hit: boolean;
+    weight: number;
+    detail?: string;
+}
+declare const SIGNALS: {
+    readonly webdriver: () => SignalResult;
+    readonly chromedriver: () => SignalResult;
+    readonly headlessUa: () => SignalResult;
+    readonly languages: () => SignalResult;
+    readonly permissions: () => SignalResult;
+    readonly plugins: () => SignalResult;
+};
+type DomSignalName = keyof typeof SIGNALS;
+interface DetectDomOptions {
+    /** Floor below which we report no DOM agent. Defaults to 0.4. */
+    threshold?: number;
+}
+declare const detectDom: (options?: DetectDomOptions) => AgentIdentity | null;
+
+type DetectorStatus = 'stable' | 'beta' | 'research';
+interface Detector {
+    id: string;
+    status: DetectorStatus;
+    detect(): AgentIdentity | null | Promise<AgentIdentity | null>;
+}
+declare const bundledDetectors: () => Detector[];
+declare const createDetectorRegistry: (initial?: Detector[]) => {
+    register(detector: Detector): void;
+    list(status?: DetectorStatus): Detector[];
+    detectAll(includeResearch?: boolean): Promise<AgentIdentity | null>;
+};
+type DetectorRegistry = ReturnType<typeof createDetectorRegistry>;
+
+interface DetectAgentOptions {
+    webmcp?: DetectWebMcpOptions | false;
+    dom?: DetectDomOptions | false;
+    customDetectors?: Detector[];
+    experimental?: boolean;
+}
+/**
+ * Run the full detection pipeline. WebMCP wins if present (exact match), then DOM heuristics.
+ * Returns `null` if no agent class fires above its threshold — caller should treat as "human or
+ * undetectable agent."
+ */
+declare const detectAgent: (options?: DetectAgentOptions) => Promise<AgentIdentity | null>;
+
+interface PresentIdentityOptions extends IdentityClaim {
+    /**
+     * If false, accept the claim as `declared` (no remote verification).
+     * If true, the claim is staged for the gateway to verify; trust is `declared` until then.
+     */
+    verifyRemotely?: boolean;
+}
+interface PresentedIdentity {
+    identity: AgentIdentity;
+    claim: IdentityClaim;
+}
+declare const createIdentityStore: () => {
+    present(input: PresentIdentityOptions): PresentedIdentity;
+    clear(): void;
+    /** Return the presented identity if it outranks the supplied detection. */
+    preferOver(detected: AgentIdentity | null): AgentIdentity | null;
+    snapshot(): PresentedIdentity | null;
+};
+type IdentityStore = ReturnType<typeof createIdentityStore>;
+
+interface SamplerOptions {
+    traceRate?: number;
+    errorRate?: number;
+    random?: () => number;
+}
+
+interface TraceExporter {
+    name: string;
+    export(events: TraceEvent[]): Promise<void> | void;
+}
+interface TraceInput {
+    type: TraceEventType;
+    outcome?: TraceEvent['outcome'];
+    tool?: string;
+    agent?: TraceEvent['agent'];
+    policy?: TraceEvent['policy'];
+    durationMs?: number;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+interface TracerOptions extends SamplerOptions {
+    siteId: string;
+    bufferSize?: number;
+    sessionId?: string;
+    scrubPaths?: string[];
+    exporters?: TraceExporter[];
+    onExporterError?: (error: unknown, exporter: TraceExporter, event: TraceEvent) => void;
+}
+interface Tracer {
+    readonly sessionId: string;
+    emit(input: TraceInput): Promise<TraceEvent | null>;
+    list(): TraceEvent[];
+    clear(): void;
+}
+declare const createTracer: ({ siteId, bufferSize, sessionId, scrubPaths, exporters, onExporterError, ...samplerOptions }: TracerOptions) => Tracer;
+
+type AuthMethodName = 'detection' | 'selfDeclaration' | 'bearer' | 'xAgentHeader' | 'extensionToken' | 'sessionLink' | 'oauth2';
+interface AuthInput {
+    detected?: AgentIdentity | null;
+    declaration?: IdentityClaim;
+    bearerToken?: string;
+    xAgentHeader?: string;
+    extensionToken?: string;
+    sessionLinkToken?: string;
+    linkedUserId?: string;
+    oauth2AccessToken?: string;
+    oauth2Subject?: string;
+    vendorHint?: string;
+    classHint?: AgentClass;
+}
+interface AuthContext {
+    verifyToken?: (method: Exclude<AuthMethodName, 'detection' | 'selfDeclaration' | 'xAgentHeader'>, token: string) => Promise<VerificationResult | null>;
+}
+interface AuthMethod {
+    name: AuthMethodName;
+    authenticate(input: AuthInput, context: AuthContext): Promise<AgentIdentity | null>;
+}
+interface AuthEngineOptions {
+    methods?: AuthMethod[];
+    context?: AuthContext;
+    onTrace?: (input: TraceInput) => void;
+}
+declare const createAuthEngine: ({ methods, context, onTrace, }?: AuthEngineOptions) => {
+    authenticate(input: AuthInput): Promise<AgentIdentity | null>;
+    methods(): AuthMethodName[];
+};
+type AuthEngine = ReturnType<typeof createAuthEngine>;
+
+interface AgentContextSnapshot {
+    identity: AgentIdentity | null;
+    source: 'detect' | 'declare' | 'authenticate' | 'cleared' | 'initial';
+    updatedAt: string | null;
+}
+type AgentContextListener = (snapshot: AgentContextSnapshot) => void;
+declare const createAgentContextStore: () => {
+    snapshot(): AgentContextSnapshot;
+    set(identity: AgentIdentity | null, source: AgentContextSnapshot["source"]): void;
+    subscribe(listener: AgentContextListener): () => void;
+};
+type AgentContextStore = ReturnType<typeof createAgentContextStore>;
+
+interface RateLimitRule {
+    max: number;
+    windowSeconds: number;
+}
+interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+}
+interface RateLimiterStorage {
+    read(key: string): string | null;
+    write(key: string, value: string): void;
+}
+declare const createRateLimiter: (storage?: RateLimiterStorage) => {
+    consume(key: string, rule: RateLimitRule, now?: number): RateLimitResult;
+};
+type RateLimiter = ReturnType<typeof createRateLimiter>;
+
+interface EvaluateInput {
+    tool: string;
+    identity: AgentIdentity | null;
+}
+interface PolicyEngineOptions {
+    rateLimiter?: RateLimiter;
+}
+declare const createPolicyEngine: (initial?: PolicyRule[], options?: PolicyEngineOptions) => {
+    set(next: PolicyRule[]): void;
+    list(): PolicyRule[];
+    evaluate({ tool, identity }: EvaluateInput): PolicyEvaluation;
+};
+type PolicyEngine = ReturnType<typeof createPolicyEngine>;
+
+interface PolicyCacheOptions {
+    gatewayUrl: string;
+    siteId: string;
+    publishableKey: string;
+    fetcher?: typeof fetch;
+}
+interface PolicyCacheSnapshot {
+    policies: PolicyRule[];
+    etag: string | null;
+}
+declare const createPolicyCache: ({ gatewayUrl, siteId, publishableKey, fetcher, }: PolicyCacheOptions) => {
+    snapshot(): PolicyCacheSnapshot;
+    sync(): Promise<PolicyCacheSnapshot>;
+};
+type PolicyCache = ReturnType<typeof createPolicyCache>;
+
+interface MemoryGetOptions {
+    scope?: MemoryScope;
+}
+interface MemorySetOptions {
+    scope?: MemoryScope;
+    ttlSeconds?: number;
+}
+interface MemoryStoreOptions {
+    onTrace?: (input: TraceInput) => void;
+}
+declare const createMemoryStore: (options?: MemoryStoreOptions) => {
+    get: (key: string, options?: MemoryGetOptions) => unknown;
+    set: (key: string, value: unknown, options?: MemorySetOptions) => MemoryEntry;
+    remove: (key: string, options?: MemoryGetOptions) => void;
+    list: (options?: MemoryGetOptions) => MemoryEntry[];
+    clear: (options?: MemoryGetOptions) => void;
+};
+type MemoryStore = ReturnType<typeof createMemoryStore>;
+
+interface SiteMemoryStoreOptions {
+    initial?: Partial<SiteMemory>;
+    onTrace?: (input: TraceInput) => void;
+}
+interface ProvideForPageInput {
+    path: string;
+    payload: Record<string, unknown>;
+}
+type SiteMemoryListener = (snapshot: SiteMemory) => void;
+declare const createSiteMemoryStore: (options?: SiteMemoryStoreOptions) => {
+    provide: (next: Partial<SiteMemory>) => SiteMemory;
+    update: (path: string, value: unknown) => SiteMemory;
+    provideForPage: (input: ProvideForPageInput) => SiteMemoryPageContext;
+    snapshot: () => SiteMemory;
+    get: (path?: string) => unknown;
+    getForPage: (path: string) => SiteMemoryPageContext | null;
+    replace: (next: SiteMemory) => SiteMemory;
+    subscribe: (listener: SiteMemoryListener) => (() => void);
+};
+type SiteMemoryStore = ReturnType<typeof createSiteMemoryStore>;
+
+interface MemoryCacheOptions {
+    gatewayUrl: string;
+    siteId: string;
+    publishableKey: string;
+    fetcher?: typeof fetch;
+}
+interface MemoryCacheSnapshot {
+    memory: SiteMemory | null;
+    etag: string | null;
+}
+declare const createMemoryCache: ({ gatewayUrl, siteId, publishableKey, fetcher, }: MemoryCacheOptions) => {
+    snapshot(): MemoryCacheSnapshot;
+    sync(): Promise<MemoryCacheSnapshot>;
+};
+type MemoryCache = ReturnType<typeof createMemoryCache>;
+
+interface GovernedTool<Input = unknown, Output = unknown> {
+    name: string;
+    version?: string;
+    group?: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    stage?: string;
+    authz?: Omit<PolicyRule, 'id' | 'tool'>;
+    rateLimit?: PolicyRule['rateLimit'];
+    execute: (input: Input, context: {
+        identity: AgentIdentity | null;
+    }) => Promise<Output> | Output;
+}
+interface ToolRegistryOptions {
+    evaluate: (tool: string, options?: {
+        identity?: AgentIdentity | null;
+    }) => Promise<PolicyEvaluation>;
+    setPolicies?: (rules: PolicyRule[]) => void;
+    listPolicies?: () => PolicyRule[];
+    onTrace?: (input: TraceInput) => void;
+}
+interface ToolRegistry {
+    register(tool: GovernedTool): () => void;
+    unregister(name: string): void;
+    enable(name: string): void;
+    disable(name: string): void;
+    isEnabled(name: string): boolean;
+    list(options?: {
+        includeDisabled?: boolean;
+    }): GovernedTool[];
+    get(name: string): GovernedTool | undefined;
+    execute<Input, Output>(name: string, input: Input, identity?: AgentIdentity | null): Promise<Output>;
+}
+declare const createToolRegistry: ({ evaluate, setPolicies, listPolicies, onTrace, }: ToolRegistryOptions) => ToolRegistry;
+
+interface ProgressionTransition {
+    on: string;
+    to: string;
+}
+interface ProgressionStage {
+    name: string;
+    enables?: string[];
+    transitions?: ProgressionTransition[];
+}
+interface ProgressionConfig {
+    initial: string;
+    stages: ProgressionStage[];
+}
+interface ProgressionStore {
+    current(): string;
+    enabledStages(): string[];
+    notify(toolName: string): {
+        changed: boolean;
+        from: string;
+        to: string;
+    };
+    set(stage: string): {
+        changed: boolean;
+        from: string;
+        to: string;
+    };
+    reset(): void;
+    snapshot(): {
+        current: string;
+        enabled: string[];
+    };
+}
+declare const createProgressionStore: (config: ProgressionConfig, options?: {
+    onTrace?: (input: TraceInput) => void;
+}) => ProgressionStore;
+
+interface SurfacingContext {
+    identity: AgentIdentity | null;
+    stage?: string | null;
+    enabledStages?: string[];
+}
+interface SurfacingDecision {
+    tool: GovernedTool;
+    visible: boolean;
+    reason: string;
+}
+declare const decideSurfacing: (tool: GovernedTool, context: SurfacingContext) => SurfacingDecision;
+declare const surfaceTools: (tools: GovernedTool[], context: SurfacingContext) => GovernedTool[];
+declare const explainSurfacing: (tools: GovernedTool[], context: SurfacingContext) => SurfacingDecision[];
+
+declare const DEFAULT_GROUP = "default";
+interface ToolGroupSummary {
+    name: string;
+    tools: GovernedTool[];
+}
+declare const groupTools: (tools: GovernedTool[]) => ToolGroupSummary[];
+declare const listGroupNames: (tools: GovernedTool[]) => string[];
+
+interface ToolTokenEstimate {
+    name: string;
+    characters: number;
+    tokens: number;
+}
+interface TokenBudgetReport {
+    total: number;
+    perTool: ToolTokenEstimate[];
+}
+declare const estimateToolTokens: (tool: GovernedTool) => ToolTokenEstimate;
+declare const estimateBudget: (tools: GovernedTool[]) => TokenBudgetReport;
+
+interface WebMcpToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    invoke(input?: unknown): Promise<unknown>;
+}
+interface WebMcpProvider {
+    provideContext(payload: {
+        tools: WebMcpToolDescriptor[];
+    }): {
+        revoke: () => void;
+    };
+}
+interface WebMcpAdapterOptions {
+    provider?: WebMcpProvider;
+    doc?: {
+        defaultView?: WindowLike | null;
+    } | null;
+    invoke?: (tool: GovernedTool, input: unknown) => Promise<unknown>;
+}
+interface WindowLike {
+    navigator?: {
+        modelContext?: WebMcpProvider;
+    };
+}
+interface WebMcpAdapter {
+    publish(tools: GovernedTool[]): {
+        revoked: boolean;
+    };
+    revoke(): void;
+    available(): boolean;
+}
+declare const createWebMcpAdapter: (options?: WebMcpAdapterOptions) => WebMcpAdapter;
+
+interface InitOptions {
+    publishableKey: string;
+    siteId?: string;
+    /**
+     * Override the gateway URL the SDK calls. **Reserved for local development
+     * only** — the only accepted values are `localhost` / `127.0.0.1` URLs (so
+     * `pnpm dev` against a local gateway works). Any other value throws at
+     * `init()` time.
+     *
+     * Production deployments must omit this option. The SDK is hard-coded to
+     * call `https://gateway.agentronics.dev`. Custom backends are not
+     * supported, by design — see the project README + LICENSE NOTICE.
+     *
+     * @internal — kept on the public type only so dev tooling type-checks.
+     */
+    gatewayUrl?: string;
+    debug?: boolean;
+    policies?: PolicyRule[];
+    siteMemory?: Partial<SiteMemory>;
+    auth?: AuthContext;
+    progression?: ProgressionConfig;
+    tools?: GovernedTool[];
+    trace?: {
+        enabled?: boolean;
+        bufferSize?: number;
+        traceRate?: number;
+        errorRate?: number;
+        scrubPaths?: string[];
+        exporters?: TraceExporter[];
+        gateway?: boolean;
+        webhookUrl?: string;
+    };
+}
+interface AgentronicsClient {
+    readonly publishableKey: string;
+    readonly siteId: string;
+    readonly gatewayUrl: string;
+    readonly debug: boolean;
+    readonly memory: MemoryStore;
+    readonly siteMemory: SiteMemoryStore;
+    readonly memoryCache: MemoryCache;
+    readonly tracer: Tracer;
+    readonly auth: AuthEngine;
+    readonly agentContext: AgentContextStore;
+    readonly authz: PolicyEngine;
+    readonly policyCache: PolicyCache;
+    readonly tools: ToolRegistry;
+    readonly progression: ProgressionStore | null;
+    readonly webmcp: WebMcpAdapter;
+    detect(options?: DetectAgentOptions): Promise<AgentIdentity | null>;
+    authenticate(input: AuthInput): Promise<AgentIdentity | null>;
+    presentIdentity(input: PresentIdentityOptions): PresentedIdentity;
+    clearIdentity(): void;
+    presentedIdentity(): PresentedIdentity | null;
+    setPolicies(rules: PolicyRule[]): void;
+    listPolicies(): PolicyRule[];
+    evaluate(tool: string, options?: {
+        identity?: AgentIdentity | null;
+    }): Promise<PolicyEvaluation>;
+    syncPolicies(): Promise<PolicyRule[]>;
+    syncSiteMemory(): Promise<SiteMemory | null>;
+    provideSiteMemory(memory: Partial<SiteMemory>): SiteMemory;
+    provideForPage(input: ProvideForPageInput): void;
+    installMemoryDelivery(options?: {
+        metaTags?: boolean;
+        overlay?: boolean;
+    }): {
+        uninstall: () => void;
+    };
+    fetchWellKnown(origin?: string): Promise<SiteMemory | null>;
+    installDomEnforcer(): {
+        uninstall: () => void;
+    };
+    registerTool(tool: GovernedTool): () => void;
+    surfaceTools(options?: {
+        identity?: AgentIdentity | null;
+    }): GovernedTool[];
+    explainSurfacing(options?: {
+        identity?: AgentIdentity | null;
+    }): SurfacingDecision[];
+    groupedTools(options?: {
+        identity?: AgentIdentity | null;
+    }): ToolGroupSummary[];
+    estimateTokens(options?: {
+        identity?: AgentIdentity | null;
+    }): TokenBudgetReport;
+    publishToWebMcp(options?: {
+        identity?: AgentIdentity | null;
+    }): {
+        revoked: boolean;
+        surfaced: number;
+    };
+    notifyToolInvoked(toolName: string): void;
+    traces(): TraceEvent[];
+    clearTraces(): void;
+    /**
+     * Sanity-check the publishable key + gateway URL. Hits `GET /v1/health` and
+     * resolves to `{ ok: true, ... }` on 2xx, `{ ok: false, status, error }`
+     * otherwise. Doesn't throw — designed for "did my key wire up correctly?"
+     * UX without forcing the host page into a try/catch.
+     */
+    ping(): Promise<{
+        ok: true;
+        status: number;
+        body: unknown;
+    } | {
+        ok: false;
+        status: number;
+        error: string;
+    }>;
+}
+declare const init: (options: InitOptions) => AgentronicsClient;
+
+export { createProgressionStore as $, type AgentronicsClient as A, type ToolGroupSummary as B, type ToolRegistry as C, type DetectAgentOptions as D, type ToolTokenEstimate as E, type TraceInput as F, type GovernedTool as G, type Tracer as H, type InitOptions as I, type WebMcpAdapterOptions as J, type WebMcpProvider as K, type WebMcpToolDescriptor as L, type MemoryCache as M, bundledDetectors as N, createAgentContextStore as O, type PolicyEngine as P, createAuthEngine as Q, type RateLimiter as R, type SiteMemoryListener as S, type TraceExporter as T, createDetectorRegistry as U, createIdentityStore as V, type WebMcpAdapter as W, createMemoryCache as X, createMemoryStore as Y, createPolicyCache as Z, createPolicyEngine as _, type AgentContextListener as a, createRateLimiter as a0, createSiteMemoryStore as a1, createToolRegistry as a2, createTracer as a3, createWebMcpAdapter as a4, decideSurfacing as a5, detectAgent as a6, detectDom as a7, estimateBudget as a8, estimateToolTokens as a9, explainSurfacing as aa, groupTools as ab, init as ac, listGroupNames as ad, surfaceTools as ae, type AgentContextSnapshot as b, type AgentContextStore as c, type AuthEngine as d, type AuthInput as e, type AuthMethod as f, DEFAULT_GROUP as g, type DetectDomOptions as h, type Detector as i, type DetectorRegistry as j, type DetectorStatus as k, type DomSignalName as l, type IdentityStore as m, type MemoryStore as n, type PolicyCache as o, type PresentIdentityOptions as p, type PresentedIdentity as q, type ProgressionConfig as r, type ProgressionStage as s, type ProgressionStore as t, type ProgressionTransition as u, type ProvideForPageInput as v, type SiteMemoryStore as w, type SurfacingContext as x, type SurfacingDecision as y, type TokenBudgetReport as z };