@illuma-ai/agents 1.4.0-alpha.6 → 1.5.0

package/dist/types/content/ContentStore.d.ts

@@ -1,140 +0,0 @@
-import type Keyv from 'keyv';
-import type { StoreEntry, StoredEntry, ContentMetadata, ReadResult, ReadAllResult, SearchMatch, EditResult } from './types';
-/**
- * Default 3-minute TTL for ephemeral content entries. Resets on every
- * access. Kept short to reduce cache-backing memory pressure — callers
- * that persist to durable storage (see {@link ArtifactStore}) rely on
- * lazy restore from the durable backend on cache miss.
- *
- * Exported so consumers can construct their injected {@link Keyv}
- * instance with a matching TTL without hard-coding the number.
- */
-export declare const CONTENT_TTL_MS = 180000;
-/**
- * Per-conversation content store backed by a caller-provided {@link Keyv}
- * cache (typically Keyv + @keyv/redis, with in-memory fallback).
- *
- * Stores large content (MCP results, artifacts, agent-generated text)
- * outside the LLM context window. Entries inherit the TTL configured on
- * the injected {@link Keyv} instance — {@link CONTENT_TTL_MS} is the
- * recommended default.
- *
- * The caller is responsible for namespacing the Keyv instance per
- * conversation so content_ids don't collide across threads.
- *
- * @example
- * ```ts
- * import Keyv from 'keyv';
- * const cache = new Keyv({ namespace: `content-store::${conversationId}`, ttl: CONTENT_TTL_MS });
- * const store = new ContentStore(cache);
- * const id = await store.store({ name: 'report.csv', type: 'text/plain', content: csv, source: 'mcp:sharepoint' });
- * const result = await store.readLines(id, 1, 50);
- * ```
- */
-export declare class ContentStore {
-    protected cache: Keyv;
-    protected indexKey: string;
-    /**
-     * @param cache - A pre-namespaced {@link Keyv} instance. The store
-     *   writes both content entries and a per-store `_index` key, so
-     *   callers MUST namespace the Keyv per conversation to avoid
-     *   cross-thread collisions.
-     */
-    constructor(cache: Keyv);
-    /**
-     * Store new content and return a content ID.
-     * @param entry - The content to store with metadata.
-     * @returns The generated content ID.
-     */
-    store(entry: StoreEntry): Promise<string>;
-    /**
-     * Get metadata for a content entry without loading the full content.
-     * @param contentId - The content entry ID.
-     * @returns Metadata or null if not found.
-     */
-    info(contentId: string): Promise<ContentMetadata | null>;
-    /**
-     * Read lines from a content entry with optional range.
-     * Lines are 1-based and inclusive. Returns formatted content with line numbers.
-     *
-     * @param contentId - The content entry ID.
-     * @param startLine - First line to read (1-based, default 1).
-     * @param endLine - Last line to read (inclusive, default startLine + DEFAULT_READ_LINES - 1).
-     * @returns Read result with formatted content and range info, or null if not found.
-     */
-    readLines(contentId: string, startLine?: number, endLine?: number): Promise<ReadResult | null>;
-    /**
-     * Read the full content of an entry without line-number formatting or line caps.
-     * Used by API endpoints that serve complete content to the frontend (e.g., CodeViz).
-     * Unlike readLines(), this has no MAX_READ_LINES cap and returns raw content.
-     *
-     * @param contentId - The content entry ID.
-     * @returns Raw content with total line/char counts, or null if not found.
-     */
-    readAll(contentId: string): Promise<ReadAllResult | null>;
-    /**
-     * Search for a pattern within a content entry.
-     * Supports plain text matching and regex patterns.
-     *
-     * @param contentId - The content entry ID.
-     * @param pattern - Text or regex pattern to match.
-     * @param maxResults - Maximum matches to return (default MAX_SEARCH_RESULTS).
-     * @returns Array of matches with line numbers, or null if content not found.
-     */
-    search(contentId: string, pattern: string, maxResults?: number): Promise<SearchMatch[] | null>;
-    /**
-     * Surgical string replacement within a content entry.
-     * Fails if old_str is not found or appears more than once (ambiguous).
-     *
-     * Uses layered matching: exact → line-number-stripped → CRLF-normalized → trailing-whitespace-trimmed.
-     * On failure, returns diagnostic context showing nearby content to help the agent self-correct.
-     *
-     * @param contentId - The content entry ID.
-     * @param oldStr - Exact string to find.
-     * @param newStr - Replacement string.
-     * @returns Edit result with diff and affected line info.
-     */
-    strReplace(contentId: string, oldStr: string, newStr: string): Promise<EditResult>;
-    /**
-     * Overwrite content for an existing entry, preserving its name/source/type.
-     * @param contentId - The content entry ID.
-     * @param content - New content to write.
-     * @throws If content ID is not found.
-     */
-    write(contentId: string, content: string): Promise<void>;
-    /**
-     * List all content entries in this conversation's store.
-     * @returns Array of metadata for all entries.
-     */
-    list(): Promise<ContentMetadata[]>;
-    /**
-     * Get the raw content string for a content entry, without line-number formatting.
-     * Resets TTL on access. Used by code edit wrapper to retrieve stored code for execution.
-     *
-     * @param contentId - The content entry ID.
-     * @returns Raw content string, or null if not found/expired.
-     */
-    getRawContent(contentId: string): Promise<string | null>;
-    /**
-     * Delete a content entry.
-     * @param contentId - The content entry ID.
-     */
-    delete(contentId: string): Promise<void>;
-    /**
-     * Reset TTL on both a content entry and the index.
-     * Called on every access to keep active content alive.
-     * @param contentId - The content entry ID.
-     * @param stored - The stored entry to re-set (resets TTL via Keyv).
-     */
-    protected touchEntry(contentId: string, stored: StoredEntry): Promise<void>;
-    /**
-     * Retrieve the full stored entry (content + metadata) from Redis.
-     * Returns null if the entry has expired or doesn't exist.
-     */
-    protected getStored(contentId: string): Promise<StoredEntry | null>;
-    /**
-     * Retrieve the conversation's content index from Redis.
-     * The index maps content IDs to their metadata.
-     */
-    protected getIndex(): Promise<Record<string, ContentMetadata>>;
-}

package/dist/types/content/contentAnalyzer.d.ts

@@ -1,38 +0,0 @@
-/**
- * Utilities for measuring, classifying, and previewing content.
- * Used by the content_tool and MCP auto-caching (Phase 2) to decide
- * when content is "large" and how to summarize it for the LLM.
- */
-/** Content size measurements. */
-export interface ContentMeasurement {
-    totalChars: number;
-    totalLines: number;
-    /** True if content exceeds the large-content threshold. */
-    isLarge: boolean;
-}
-/** Detected content type. */
-export type ContentType = 'json_array' | 'json_object' | 'text' | 'mixed';
-/**
- * Measure content size and determine if it exceeds the large-content threshold.
- * @param text - The content to measure.
- * @returns Measurement with char count, line count, and large flag.
- */
-export declare function measureContent(text: string): ContentMeasurement;
-/**
- * Detect the structural type of content.
- * @param text - The content to classify.
- * @returns The detected type: 'json_array', 'json_object', 'text', or 'mixed'.
- */
-export declare function detectContentType(text: string): ContentType;
-/**
- * Generate a preview/summary of content for the LLM context.
- * For JSON arrays, shows the first N items. For text, truncates with an ellipsis.
- *
- * @param text - The full content to preview.
- * @param opts - Options controlling preview size.
- * @returns A truncated preview string.
- */
-export declare function generatePreview(text: string, opts?: {
-    maxItems?: number;
-    maxChars?: number;
-}): string;

package/dist/types/content/index.d.ts

@@ -1,24 +0,0 @@
-/**
- * @illuma-ai/agents/content — per-conversation content + artifact stores.
- *
- * Host-agnostic primitives for keeping large tool / agent output out of
- * the LLM context window:
- *
- *   - {@link ContentStore} — ephemeral per-conversation cache (backed by
- *     any caller-provided {@link Keyv} instance; recommended with
- *     @keyv/redis for multi-instance deployments).
- *   - {@link ArtifactStore} — extends {@link ContentStore} with
- *     durable persistence via caller-provided {@link S3Strategy} and
- *     {@link FileModel} adapters.
- *   - {@link interceptMcpResult} — MCP tool-result auto-caching with
- *     gate semantics (no-op when the agent can't dereference
- *     `content_id`s).
- *   - {@link measureContent} / {@link detectContentType} /
- *     {@link generatePreview} — content classifiers shared by
- *     consumers that need to decide when to store vs inline.
- */
-export { ContentStore, CONTENT_TTL_MS } from './ContentStore';
-export { ArtifactStore, sanitizeName, type S3Strategy, type FileModel, type Logger, } from './ArtifactStore';
-export { measureContent, detectContentType, generatePreview, type ContentMeasurement, type ContentType, } from './contentAnalyzer';
-export type { StoreEntry, StoredEntry, ContentMetadata, ReadResult, ReadAllResult, SearchMatch, EditResult, } from './types';
-export { interceptMcpResult, extractUiMarkers, buildCachedResponse, type AutoCacheContext, type AutoCacheResult, } from './mcpAutoCache';

package/dist/types/content/mcpAutoCache.d.ts

@@ -1,89 +0,0 @@
-/**
- * MCP Auto-Caching Interceptor
- *
- * When an MCP tool returns a large text result (>50K chars / ~12.5K tokens),
- * stores it in the caller-provided {@link ContentStore} and returns a
- * compact metadata reference. The LLM then uses a `content_reader` tool
- * (read/search/list/info) to pull relevant pieces of the stored result
- * without burning tokens on the full payload.
- *
- * Gate: callers MUST pass `contentReaderEnabled: true` on the context —
- * otherwise the interceptor returns the original text unchanged, because
- * caching without a reader tool leaves the agent with a content_id it
- * cannot dereference.
- *
- * Design:
- * - Only text content is cached. Images and UI resources pass through.
- * - UI resource markers (\ui{...}) are preserved in the returned text.
- * - Artifacts (second element of the tuple) are never modified.
- * - Cached response is a compact one-liner (~30 tokens) — no preview blob.
- * - If the store write fails, degrades gracefully — returns original text.
- */
-import { ContentStore } from './ContentStore';
-import type { Logger } from './ArtifactStore';
-import type { ContentMeasurement } from './contentAnalyzer';
-/** Context for the auto-cache interceptor. */
-export interface AutoCacheContext {
-    /**
-     * Pre-constructed {@link ContentStore} instance scoped to the current
-     * conversation. Caller owns the underlying cache lifecycle.
-     */
-    store: ContentStore;
-    /** MCP server name (e.g. "sharepoint", "github"). */
-    serverName: string;
-    /** MCP tool name (e.g. "read_file", "search_code"). */
-    toolName: string;
-    /**
-     * Whether the current agent has `content_reader` available. When false,
-     * the interceptor passes the large text through unchanged — caching
-     * without a reader tool leaves the agent with a content_id it cannot
-     * dereference, which is worse than returning the raw text.
-     */
-    contentReaderEnabled: boolean;
-    /**
-     * Optional diagnostic echo. Typically the conversation ID so operators
-     * can correlate the log line with upstream traces.
-     */
-    conversationId?: string;
-    /** Optional logger; defaults to silence. */
-    logger?: Logger;
-}
-/** Result of the auto-cache interception. */
-export interface AutoCacheResult {
-    /** The (possibly modified) text content to return to the LLM. */
-    text: string;
-    /** Whether the content was cached. */
-    cached: boolean;
-    /** The content_id if cached. */
-    contentId?: string;
-    /** Content measurement data. */
-    measurement?: ContentMeasurement;
-}
-/**
- * Extract all UI resource markers from text.
- * @param text - The text to scan.
- * @returns Array of marker strings (e.g. ['\\ui{abc123}', '\\ui{def456}'])
- */
-export declare function extractUiMarkers(text: string): string[];
-/**
- * Build a compact metadata reference for the cached content.
- * Keeps token usage minimal (~30 tokens) while giving the LLM all it needs
- * to access the data via content_tool.
- *
- * @param contentId - ContentStore entry ID.
- * @param measurement - Size data.
- * @param toolName - The MCP tool that produced the result.
- * @param uiMarkers - UI markers extracted from the original text.
- */
-export declare function buildCachedResponse(contentId: string, measurement: ContentMeasurement, toolName: string, uiMarkers: string[]): string;
-/**
- * Core auto-cache interceptor for MCP tool results.
- *
- * If the text exceeds the large-content threshold (50K chars), stores it
- * in ContentStore and returns a preview + content_id. Otherwise passes through.
- *
- * @param text - The text content from the MCP tool result.
- * @param context - MCP tool and conversation context.
- * @returns AutoCacheResult with possibly-modified text and caching metadata.
- */
-export declare function interceptMcpResult(text: string, context: AutoCacheContext): Promise<AutoCacheResult>;

package/dist/types/content/types.d.ts

@@ -1,75 +0,0 @@
-/**
- * Types for the per-conversation content store.
- * Content entries are ephemeral (Redis-backed, 5 min TTL) and used to keep
- * large tool results out of the LLM context window.
- */
-/** Input when storing new content. */
-export interface StoreEntry {
-    /** Human-readable name (e.g. "Q1 Sales Report.xlsx") */
-    name: string;
-    /** MIME-like type: "text/plain", "application/json", "mcp_response", "artifact" */
-    type: string;
-    /** The raw content string */
-    content: string;
-    /** Origin identifier: "mcp:sharepoint", "artifact:msg123", "agent", etc. */
-    source: string;
-    /** Arbitrary extra data attached to the entry */
-    metadata?: Record<string, unknown>;
-}
-/** Metadata returned by info() and list() — content is NOT included. */
-export interface ContentMetadata {
-    id: string;
-    name: string;
-    type: string;
-    source: string;
-    totalLines: number;
-    totalChars: number;
-    createdAt: number;
-    /** MongoDB File.file_id after persistence to S3 (set by ArtifactStore) */
-    fileId?: string;
-    /** Owner user ID (set by ArtifactStore for S3 path construction) */
-    userId?: string;
-    /** Conversation scope (set by ArtifactStore for S3 path construction) */
-    conversationId?: string;
-    /** True when the file exists in MongoDB but hasn't been ingested into ContentStore yet */
-    needsIngestion?: boolean;
-}
-/** Result of a readLines() call. */
-export interface ReadResult {
-    /** Formatted content with line numbers */
-    content: string;
-    startLine: number;
-    endLine: number;
-    totalLines: number;
-    totalChars: number;
-    /** True if there are more lines beyond endLine */
-    truncated: boolean;
-}
-/** Result of a readAll() call — raw content without line-number formatting. */
-export interface ReadAllResult {
-    /** Raw content string (no line-number prefixes) */
-    content: string;
-    totalLines: number;
-    totalChars: number;
-}
-/** A single search match within content. */
-export interface SearchMatch {
-    lineNumber: number;
-    content: string;
-}
-/** Result of a strReplace() edit. */
-export interface EditResult {
-    success: boolean;
-    /** Human-readable diff snippet */
-    diff: string;
-    /** Line number where the replacement occurred */
-    lineNumber: number;
-    /** Number of lines affected by the edit */
-    linesAffected: number;
-    error?: string;
-}
-/** Internal shape stored in Redis for each content entry. */
-export interface StoredEntry {
-    content: string;
-    metadata: ContentMetadata;
-}

package/dist/types/graphs/HandoffRegistry.d.ts

@@ -1,97 +0,0 @@
-import type { BaseMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-/**
- * Tracks the lifecycle of a spawned handoff child agent.
- */
-export type HandoffRecord = {
-    /** Agent identity (destination agentId) — stable across multiple spawns of the same agent */
-    id: string;
-    /** Unique internal key for this specific spawn (agentId + monotonic counter) */
-    spawnKey: string;
-    /** Display name of the child agent */
-    name: string;
-    /** Task description / instructions passed to child */
-    task: string;
-    /** When the handoff was spawned */
-    spawnedAt: number;
-    /** Current status */
-    status: 'pending' | 'running' | 'completed' | 'failed';
-    /** The background promise executing the child subgraph */
-    promise: Promise<t.BaseGraphState>;
-    /** Resolved result text (populated on completion) */
-    resultText?: string;
-    /** Error message (populated on failure) */
-    error?: string;
-    /** Duration in ms (populated on completion/failure) */
-    durationMs?: number;
-    /** Number of messages in child's output */
-    resultMessageCount?: number;
-};
-/**
- * Registry for async handoff execution.
- *
- * Enables the autonomous orchestration pattern:
- * 1. Orchestrator spawns children (non-blocking)
- * 2. Orchestrator stays alive to reason, spawn more, or check status
- * 3. Orchestrator collects results when ready
- *
- * Scoped per MultiAgentGraph instance — each orchestrator graph gets its own registry.
- */
-export declare class HandoffRegistry {
-    private records;
-    /** Monotonically increasing counter for unique spawn IDs */
-    private spawnCounter;
-    /**
-     * Register a spawned handoff child.
-     * The promise runs in the background — not awaited here.
-     * Uses a unique key per spawn so the same agent can be spawned multiple times
-     * across rounds without overwriting prior records.
-     */
-    spawn(params: {
-        id: string;
-        name: string;
-        task: string;
-        promise: Promise<t.BaseGraphState>;
-        extractResult: (messages: BaseMessage[], agentId: string) => string;
-        truncateResult: (text: string, maxChars: number) => string;
-        maxResultChars: number;
-        /** Callback when child completes (for SSE events) */
-        onComplete?: (record: HandoffRecord) => void;
-    }): void;
-    /** List all pending (running) handoffs */
-    listPending(): HandoffRecord[];
-    /** List all completed handoffs (not yet collected) */
-    listCompleted(): HandoffRecord[];
-    /** List all handoffs regardless of status */
-    listAll(): HandoffRecord[];
-    /**
-     * Get a handoff record by either its unique spawnKey or by agentId.
-     * - Exact spawnKey match wins (O(1)).
-     * - Falls back to the most recently spawned record for that agentId — matching
-     *   lookups by callers that only know the agent identity, not the spawn round.
-     */
-    get(idOrSpawnKey: string): HandoffRecord | undefined;
-    /** Check if any handoffs are still running */
-    hasPending(): boolean;
-    /**
-     * Wait for ALL pending handoffs to complete and return all records.
-     * Records are NOT auto-cleared — caller removes collected records via remove().
-     */
-    waitForAll(): Promise<HandoffRecord[]>;
-    /**
-     * Wait for ANY pending handoff to complete.
-     * Returns the newly completed record(s).
-     */
-    waitForAny(): Promise<HandoffRecord[]>;
-    /**
-     * Remove record(s) by spawnKey or agentId.
-     * - Exact spawnKey match removes only that record.
-     * - agentId match removes ALL records for that agent (covers callers that
-     *   want to forget everything tied to a given agent).
-     */
-    remove(idOrSpawnKey: string): void;
-    /** Clear all records (for cleanup between graph invocations) */
-    clear(): void;
-    /** Number of total tracked handoffs */
-    get size(): number;
-}

package/dist/types/providers/a2a/A2ACapabilityProvider.d.ts

@@ -1,89 +0,0 @@
-/**
- * A2ACapabilityProvider — client-side adapter for consuming A2A-served
- * remote agents as capabilities.
- *
- * Same pattern as `MCPCapabilityProvider`: take a unified spec map,
- * speak the protocol (A2A JSON-RPC over HTTP), expose each skill as a
- * `Capability` / `StructuredTool`.
- *
- * Design:
- *   - One `A2AClient` per remote spec, cached after first use.
- *   - `fetchManifest()`:
- *       for each remote, GET /.well-known/agent.json → emit one
- *       Capability per advertised skill (or one per remote when
- *       `flattenAsSingleTool` is set).
- *   - `createRunnables()`:
- *       each Capability becomes a StructuredTool whose invoke sends a
- *       JSON-RPC `tasks/send` to the remote and returns the final
- *       artifact's text.
- *
- * What the host supplies:
- *   - `remotes`: unified spec map (normalized from whatever source).
- *   - `getAuthHeaders?`: per-remote header resolver. Called at connect
- *     time. OAuth / token refresh stays in the host.
- */
-import { type StructuredToolInterface } from '@langchain/core/tools';
-import { type Capability, type CapabilityFilter, type CapabilityProvider, type CredentialMap } from '@/providers/types';
-import { CAPABILITY_NAME_SEPARATOR, formatCapabilityName } from '@/providers/capabilityNaming';
-import type { A2AProviderConfig, A2ASkill } from './types';
-export declare class A2ACapabilityProvider implements CapabilityProvider {
-    readonly providerId: string;
-    private readonly config;
-    private readonly logger;
-    private readonly connections;
-    constructor(config: A2AProviderConfig);
-    fetchManifest(filter?: CapabilityFilter): Promise<Capability[]>;
-    createRunnables(capabilities: Capability[], _credentials: CredentialMap): Promise<StructuredToolInterface[]>;
-    /** Disconnect any cached clients. A2A is stateless over HTTP so this
-     *  is effectively a cache clear — no sockets to close. */
-    close(): Promise<void>;
-    private ensureConnection;
-    private resolveAuthHeaders;
-    private cardToCapabilities;
-    private capabilityMatchesFilter;
-    private buildProxyTool;
-}
-export { CAPABILITY_NAME_SEPARATOR, formatCapabilityName };
-/**
- * Parse a capability name produced by this provider, returning A2A-specific
- * field names (`remoteName` / `skillId`). Thin adapter over the shared
- * `parseCapabilityName` — kept local so callers see the A2A vocabulary.
- */
-export declare function parseCapabilityName(name: string): {
-    remoteName: string;
-    skillId?: string;
-} | null;
-/** Derive a Capability from a skill entry on the agent card. */
-export declare function skillToCapability(remoteName: string, skill: A2ASkill): Capability;
-/**
- * Default input schema for A2A capabilities. Every invocation is a text
- * message — we don't try to infer a per-skill input shape because the
- * A2A spec's skill entries don't include a parameter schema.
- */
-export declare const MESSAGE_INPUT_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly message: {
-            readonly type: "string";
-            readonly description: "Instruction or question to send to the remote agent as a user message.";
-        };
-    };
-    readonly required: readonly ["message"];
-};
-/**
- * Coerce arbitrary LLM-supplied input into a valid A2A message. If the
- * input is a string, wraps it directly. If it's `{ message: "..." }`,
- * uses `message`. Otherwise JSON-stringifies so the agent receives
- * something it can try to interpret.
- *
- * When a skill id is known, it's prepended to the message text so the
- * remote agent can route — some A2A implementations use this, others
- * ignore it, it's best-effort.
- */
-export declare function coerceInputToA2AMessage(input: unknown, skillId?: string): {
-    role: 'user';
-    parts: Array<{
-        type: 'text';
-        text: string;
-    }>;
-};

package/dist/types/providers/a2a/client.d.ts

@@ -1,47 +0,0 @@
-/**
- * A2A HTTP client — thin wrappers for the two operations the provider
- * needs: fetching the agent card and sending JSON-RPC task requests.
- *
- * Uses axios (already in deps) via the shared httpClient utility so
- * proxy config + headers work consistently with the tools-server provider.
- */
-import type { A2AAgentCard, A2ATask, A2ATaskParams } from './types';
-/** Options for constructing a single-remote A2A client. */
-export interface A2AClientOptions {
-    baseUrl: string;
-    headers?: Record<string, string>;
-    timeoutMs?: number;
-    cardPath?: string;
-    rpcPath?: string;
-}
-/**
- * Lightweight single-remote A2A client. One instance per remote; the
- * provider builds one per spec entry and caches them.
- */
-export declare class A2AClient {
-    private readonly http;
-    private readonly cardPath;
-    private readonly rpcPath;
-    constructor(opts: A2AClientOptions);
-    /** GET /.well-known/agent.json (or the configured override). */
-    fetchAgentCard(): Promise<A2AAgentCard>;
-    /**
-     * POST a JSON-RPC `tasks/send` request and return the resulting Task.
-     * The caller supplies the params (id, sessionId, message); this helper
-     * wraps it in the JSON-RPC envelope, dispatches, and unwraps.
-     */
-    sendTask(params: A2ATaskParams): Promise<A2ATask>;
-    /** Low-level JSON-RPC dispatcher — exposed for tests / advanced callers. */
-    rpc<P, R>(method: string, params: P): Promise<R>;
-}
-/**
- * Generate a short opaque id for JSON-RPC requests. Not cryptographic —
- * just unique enough to pair request/response in logs.
- */
-export declare function generateRpcId(): string;
-/**
- * Extract the plain-text output from a completed Task's artifacts. If
- * the task isn't `completed`, throws. If there are no text parts, returns
- * an empty string rather than null so callers always get a string.
- */
-export declare function extractTaskText(task: A2ATask): string;

package/dist/types/providers/a2a/config.d.ts

@@ -1,18 +0,0 @@
-/**
- * Environment-driven defaults + default logger for the A2A provider.
- *
- * Mirrors the MCP provider's config.ts so the two providers have the same
- * override story for hosts.
- */
-import type { A2ALogger } from './types';
-/**
- * Read env values with fallbacks. Evaluated lazily so tests that mutate
- * process.env get the current value.
- */
-export declare function getA2AEnvDefaults(): {
-    clientName: string;
-    clientVersion: string;
-    timeoutMs: number;
-};
-/** Console-routed default logger. */
-export declare const consoleLogger: A2ALogger;

package/dist/types/providers/a2a/index.d.ts

@@ -1,6 +0,0 @@
-export { A2ACapabilityProvider } from './A2ACapabilityProvider';
-export { CAPABILITY_NAME_SEPARATOR, formatCapabilityName, parseCapabilityName, skillToCapability, coerceInputToA2AMessage, MESSAGE_INPUT_SCHEMA, } from './A2ACapabilityProvider';
-export { A2AClient, extractTaskText, generateRpcId } from './client';
-export type { A2AClientOptions } from './client';
-export { consoleLogger as a2aConsoleLogger, getA2AEnvDefaults } from './config';
-export type { A2AAgentCard, A2ACardCapabilities, A2ALogger, A2AMessage, A2AProviderConfig, A2ARemoteSpec, A2ASkill, A2ATask, A2ATaskParams, A2ATaskState, A2ATaskStatus, JsonRpcRequest, JsonRpcResponse, JsonRpcSuccess, JsonRpcErrorResponse, } from './types';