@illuma-ai/agents 1.3.1 → 1.4.0-alpha.0

package/src/providers/__tests__/ToolsServerCapabilityProvider.test.ts

@@ -0,0 +1,206 @@
+import axios from 'axios';
+import { ToolsServerCapabilityProvider } from '../tools-server/ToolsServerCapabilityProvider';
+import { CapabilityKind } from '../types';
+
+/**
+ * Tests use a stub axios instance passed via config — no real HTTP.
+ */
+function makeStubClient(response: {
+  status: number;
+  data: unknown;
+}): ReturnType<typeof axios.create> {
+  const stub = {
+    get: jest.fn().mockResolvedValue(response),
+    post: jest.fn().mockResolvedValue(response),
+    defaults: { baseURL: 'http://stub', headers: {} },
+  };
+  return stub as unknown as ReturnType<typeof axios.create>;
+}
+
+const manifestFixture = [
+  {
+    pluginKey: 'wikipedia',
+    name: 'Wikipedia',
+    description: 'Search Wikipedia',
+    icon: '/assets/icons/wikipedia.svg',
+    authConfig: [],
+    schema: { type: 'object', properties: { query: { type: 'string' } } },
+    tags: ['search', 'knowledge'],
+  },
+  {
+    pluginKey: 'dalle',
+    name: 'DALL-E 3',
+    description: 'Generate images',
+    authConfig: [
+      {
+        authField: 'OPENAI_API_KEY',
+        label: 'OpenAI API Key',
+        source: 'user',
+        required: true,
+      },
+    ],
+    jsonSchema: { type: 'object', properties: { prompt: { type: 'string' } } },
+    tags: ['image'],
+  },
+];
+
+describe('ToolsServerCapabilityProvider construction', () => {
+  it('throws when baseUrl missing', () => {
+    expect(
+      () => new ToolsServerCapabilityProvider({ baseUrl: '', apiKey: 'k' })
+    ).toThrow(/baseUrl is required/);
+  });
+  it('throws when apiKey missing', () => {
+    expect(
+      () =>
+        new ToolsServerCapabilityProvider({ baseUrl: 'http://x', apiKey: '' })
+    ).toThrow(/apiKey is required/);
+  });
+  it('composes providerId from baseUrl', () => {
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://localhost:3500',
+      apiKey: 'k',
+      client: makeStubClient({ status: 200, data: [] }),
+    });
+    expect(p.providerId).toBe('tools-server:http://localhost:3500');
+  });
+});
+
+describe('ToolsServerCapabilityProvider.fetchManifest', () => {
+  it('normalizes manifest entries into Capability shape', async () => {
+    const client = makeStubClient({ status: 200, data: manifestFixture });
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client,
+    });
+    const caps = await p.fetchManifest();
+    expect(caps).toHaveLength(2);
+    expect(caps[0].kind).toBe(CapabilityKind.TOOL);
+    expect(caps[0].name).toBe('wikipedia');
+    expect(caps[0].metadata.tags).toEqual(['search', 'knowledge']);
+    expect(caps[1].authConfig[0].authField).toBe('OPENAI_API_KEY');
+    expect(caps[1].authConfig[0].required).toBe(true);
+  });
+
+  it('caches manifest between calls', async () => {
+    const client = makeStubClient({ status: 200, data: manifestFixture });
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client,
+    });
+    await p.fetchManifest();
+    await p.fetchManifest();
+    expect((client.get as jest.Mock).mock.calls).toHaveLength(1);
+  });
+
+  it('invalidateCache forces refetch', async () => {
+    const client = makeStubClient({ status: 200, data: manifestFixture });
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client,
+    });
+    await p.fetchManifest();
+    p.invalidateCache();
+    await p.fetchManifest();
+    expect((client.get as jest.Mock).mock.calls).toHaveLength(2);
+  });
+
+  it('filters by name', async () => {
+    const client = makeStubClient({ status: 200, data: manifestFixture });
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client,
+    });
+    const caps = await p.fetchManifest({ names: ['wikipedia'] });
+    expect(caps).toHaveLength(1);
+    expect(caps[0].name).toBe('wikipedia');
+  });
+
+  it('throws HttpError on non-2xx', async () => {
+    const client = makeStubClient({ status: 500, data: { error: 'boom' } });
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client,
+    });
+    await expect(p.fetchManifest()).rejects.toThrow(/HTTP 500/);
+  });
+});
+
+describe('ToolsServerCapabilityProvider.createRunnables', () => {
+  it('returns one StructuredTool per capability', async () => {
+    const client = makeStubClient({ status: 200, data: manifestFixture });
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client,
+    });
+    const caps = await p.fetchManifest();
+    const tools = await p.createRunnables(caps, {});
+    expect(tools).toHaveLength(2);
+    expect(tools[0].name).toBe('wikipedia');
+    expect(tools[1].name).toBe('dalle');
+  });
+
+  it('proxy tool invocation POSTs to /execute/:name with credentials', async () => {
+    const client = {
+      get: jest.fn().mockResolvedValue({ status: 200, data: manifestFixture }),
+      post: jest.fn().mockResolvedValue({
+        status: 200,
+        data: {
+          success: true,
+          result: 'Node.js is a JS runtime',
+          timing: { durationMs: 42 },
+        },
+      }),
+      defaults: { baseURL: 'http://stub', headers: {} },
+    };
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client: client as unknown as ReturnType<typeof axios.create>,
+    });
+    const caps = await p.fetchManifest();
+    const [wikipedia] = await p.createRunnables(
+      caps.filter((c) => c.name === 'wikipedia'),
+      { WIKIPEDIA_API_KEY: 'test' }
+    );
+    const result = await wikipedia.invoke({ query: 'Node.js' });
+    expect(result).toBe('Node.js is a JS runtime');
+    expect((client.post as jest.Mock).mock.calls[0][0]).toBe(
+      '/execute/wikipedia'
+    );
+    expect((client.post as jest.Mock).mock.calls[0][1]).toEqual({
+      input: { query: 'Node.js' },
+      credentials: { WIKIPEDIA_API_KEY: 'test' },
+    });
+  });
+
+  it('proxy tool surfaces backend success:false as thrown error', async () => {
+    const client = {
+      get: jest.fn().mockResolvedValue({ status: 200, data: manifestFixture }),
+      post: jest.fn().mockResolvedValue({
+        status: 200,
+        data: { success: false, error: 'missing API key' },
+      }),
+      defaults: { baseURL: 'http://stub', headers: {} },
+    };
+    const p = new ToolsServerCapabilityProvider({
+      baseUrl: 'http://x',
+      apiKey: 'k',
+      client: client as unknown as ReturnType<typeof axios.create>,
+    });
+    const caps = await p.fetchManifest();
+    const [dalle] = await p.createRunnables(
+      caps.filter((c) => c.name === 'dalle'),
+      {}
+    );
+    await expect(dalle.invoke({ prompt: 'cat' })).rejects.toThrow(
+      /missing API key/
+    );
+  });
+});

package/src/providers/__tests__/types.test.ts

@@ -0,0 +1,64 @@
+import {
+  CapabilityKind,
+  AuthSource,
+  type Capability,
+  type CapabilityProvider,
+  type CredentialMap,
+} from '../types';
+
+describe('CapabilityProvider types', () => {
+  it('CapabilityKind enum covers tool/skill/mcp', () => {
+    expect(CapabilityKind.TOOL).toBe('tool');
+    expect(CapabilityKind.SKILL).toBe('skill');
+    expect(CapabilityKind.MCP).toBe('mcp');
+  });
+
+  it('AuthSource enum covers server/user/forwarded', () => {
+    expect(AuthSource.SERVER).toBe('server');
+    expect(AuthSource.USER).toBe('user');
+    expect(AuthSource.FORWARDED).toBe('forwarded');
+  });
+
+  it('Capability shape reserves upstream metadata fields', () => {
+    const cap: Capability = {
+      kind: CapabilityKind.TOOL,
+      name: 'sample',
+      description: 'test capability',
+      schema: { type: 'object' },
+      authConfig: [],
+      metadata: {
+        icon: '/icon.svg',
+        category: 'test',
+        tags: ['a', 'b'],
+        auth: 'oauth',
+        expires_at: 1735689600,
+        injectedMessages: false,
+        sessionAware: false,
+      },
+    };
+    expect(cap.name).toBe('sample');
+    expect(cap.metadata.expires_at).toBe(1735689600);
+  });
+
+  it('CredentialMap is a plain string record', () => {
+    const creds: CredentialMap = {
+      OPENAI_API_KEY: 'sk-xxx',
+      WOLFRAM_APP_ID: 'abc123',
+    };
+    expect(Object.keys(creds)).toHaveLength(2);
+  });
+
+  it('CapabilityProvider is an implementable contract', () => {
+    class FakeProvider implements CapabilityProvider {
+      readonly providerId = 'fake';
+      async fetchManifest() {
+        return [];
+      }
+      async createRunnables() {
+        return [];
+      }
+    }
+    const p: CapabilityProvider = new FakeProvider();
+    expect(p.providerId).toBe('fake');
+  });
+});

package/src/providers/a2a/A2ACapabilityProvider.ts

@@ -0,0 +1,384 @@
+/**
+ * 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 { tool, type StructuredToolInterface } from '@langchain/core/tools';
+
+import {
+  CapabilityKind,
+  type Capability,
+  type CapabilityFilter,
+  type CapabilityProvider,
+  type CredentialMap,
+} from '@/providers/types';
+import {
+  CAPABILITY_NAME_SEPARATOR,
+  formatCapabilityName,
+  parseCapabilityName as parseSharedName,
+} from '@/providers/capabilityNaming';
+import { A2AClient, extractTaskText, generateRpcId } from './client';
+import { consoleLogger, getA2AEnvDefaults } from './config';
+import type {
+  A2AAgentCard,
+  A2ALogger,
+  A2AProviderConfig,
+  A2ARemoteSpec,
+  A2ASkill,
+} from './types';
+
+/**
+ * Per-remote cached state. The agent card is fetched lazily and reused.
+ */
+interface RemoteConnection {
+  remoteName: string;
+  spec: A2ARemoteSpec;
+  client: A2AClient;
+  card: A2AAgentCard;
+}
+
+export class A2ACapabilityProvider implements CapabilityProvider {
+  readonly providerId: string;
+  private readonly config: Required<
+    Pick<A2AProviderConfig, 'clientInfo' | 'timeoutMs'>
+  > &
+    Pick<A2AProviderConfig, 'remotes' | 'getAuthHeaders'>;
+  private readonly logger: A2ALogger;
+  private readonly connections = new Map<string, RemoteConnection>();
+
+  constructor(config: A2AProviderConfig) {
+    if (!config.remotes || Object.keys(config.remotes).length === 0) {
+      throw new Error('A2ACapabilityProvider: at least one remote is required');
+    }
+    const env = getA2AEnvDefaults();
+    this.config = {
+      remotes: config.remotes,
+      getAuthHeaders: config.getAuthHeaders,
+      clientInfo: config.clientInfo ?? {
+        name: env.clientName,
+        version: env.clientVersion,
+      },
+      timeoutMs: config.timeoutMs ?? env.timeoutMs,
+    };
+    this.logger = config.logger ?? consoleLogger;
+    const names = Object.keys(config.remotes).sort().join(',');
+    this.providerId = `a2a:${names}`;
+  }
+
+  async fetchManifest(filter?: CapabilityFilter): Promise<Capability[]> {
+    if (filter?.kind && filter.kind !== CapabilityKind.A2A) return [];
+
+    const capabilities: Capability[] = [];
+    for (const remoteName of Object.keys(this.config.remotes)) {
+      try {
+        const conn = await this.ensureConnection(remoteName);
+        const caps = this.cardToCapabilities(remoteName, conn.card, conn.spec);
+        for (const cap of caps) {
+          if (this.capabilityMatchesFilter(cap, filter)) capabilities.push(cap);
+        }
+      } catch (err) {
+        // One remote failing must not block others — log and continue.
+        this.logger.warn(
+          `[a2a] failed to fetch manifest for remote "${remoteName}":`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    }
+
+    this.logger.debug(
+      `[a2a] manifest assembled — ${capabilities.length} capabilities across ${this.connections.size}/${Object.keys(this.config.remotes).length} connected remotes`
+    );
+
+    return capabilities;
+  }
+
+  async createRunnables(
+    capabilities: Capability[],
+    _credentials: CredentialMap
+  ): Promise<StructuredToolInterface[]> {
+    const runnables: StructuredToolInterface[] = [];
+    for (const cap of capabilities) {
+      if (cap.kind !== CapabilityKind.A2A) continue;
+      const parsed = parseCapabilityName(cap.name);
+      if (!parsed) {
+        this.logger.warn(
+          `[a2a] skipping capability "${cap.name}" — unparseable`
+        );
+        continue;
+      }
+      runnables.push(
+        this.buildProxyTool(parsed.remoteName, parsed.skillId, cap)
+      );
+    }
+    return runnables;
+  }
+
+  /** Disconnect any cached clients. A2A is stateless over HTTP so this
+   *  is effectively a cache clear — no sockets to close. */
+  async close(): Promise<void> {
+    this.connections.clear();
+  }
+
+  // --- internals ---------------------------------------------------------
+
+  private async ensureConnection(
+    remoteName: string
+  ): Promise<RemoteConnection> {
+    const existing = this.connections.get(remoteName);
+    if (existing) return existing;
+
+    const spec = this.config.remotes[remoteName];
+    if (!spec) {
+      throw new Error(`[a2a] remote "${remoteName}" not in config`);
+    }
+
+    const authHeaders = await this.resolveAuthHeaders(remoteName);
+    const headers = {
+      ...(spec.headers ?? {}),
+      ...(authHeaders ?? {}),
+      'user-agent': `${this.config.clientInfo.name}/${this.config.clientInfo.version}`,
+    };
+
+    const client = new A2AClient({
+      baseUrl: spec.url,
+      headers,
+      timeoutMs: this.config.timeoutMs,
+      cardPath: spec.cardPath,
+      rpcPath: spec.rpcPath,
+    });
+
+    this.logger.debug(
+      `[a2a] fetching card from "${remoteName}" at ${spec.url}`
+    );
+    const card = await client.fetchAgentCard();
+    this.logger.debug(
+      `[a2a] connected to "${remoteName}" — ${card.skills.length ?? 0} skills discovered`
+    );
+
+    const conn: RemoteConnection = { remoteName, spec, client, card };
+    this.connections.set(remoteName, conn);
+    return conn;
+  }
+
+  private async resolveAuthHeaders(
+    remoteName: string
+  ): Promise<Record<string, string> | undefined> {
+    if (!this.config.getAuthHeaders) return undefined;
+    try {
+      return await this.config.getAuthHeaders(remoteName);
+    } catch (err) {
+      this.logger.warn(
+        `[a2a] getAuthHeaders("${remoteName}") threw:`,
+        err instanceof Error ? err.message : err
+      );
+      return undefined;
+    }
+  }
+
+  private cardToCapabilities(
+    remoteName: string,
+    card: A2AAgentCard,
+    spec: A2ARemoteSpec
+  ): Capability[] {
+    if (spec.flattenAsSingleTool) {
+      // One capability per remote, named after the remote. Useful when
+      // the card has no skills listed or you want coarse routing.
+      return [
+        {
+          kind: CapabilityKind.A2A,
+          name: formatCapabilityName(remoteName),
+          description: card.description ?? card.name,
+          schema: MESSAGE_INPUT_SCHEMA,
+          authConfig: [],
+          metadata: {
+            category: 'a2a',
+            tags: [remoteName, ...(card.skills.map((s) => s.id) ?? [])],
+          },
+        },
+      ];
+    }
+
+    if (!card.skills || card.skills.length === 0) {
+      // No skills advertised — expose a single message endpoint so the
+      // agent can still invoke the remote with free-form text.
+      return [
+        {
+          kind: CapabilityKind.A2A,
+          name: formatCapabilityName(remoteName),
+          description:
+            card.description ?? `Delegate to remote agent "${card.name}".`,
+          schema: MESSAGE_INPUT_SCHEMA,
+          authConfig: [],
+          metadata: { category: 'a2a', tags: [remoteName] },
+        },
+      ];
+    }
+
+    return card.skills.map(
+      (skill): Capability => skillToCapability(remoteName, skill)
+    );
+  }
+
+  private capabilityMatchesFilter(
+    cap: Capability,
+    filter?: CapabilityFilter
+  ): boolean {
+    if (!filter) return true;
+    if (filter.kind && cap.kind !== filter.kind) return false;
+    if (filter.names && !filter.names.includes(cap.name)) return false;
+    if (filter.tags?.length) {
+      const capTags = new Set(cap.metadata.tags ?? []);
+      if (!filter.tags.some((t) => capTags.has(t))) return false;
+    }
+    return true;
+  }
+
+  private buildProxyTool(
+    remoteName: string,
+    skillId: string | undefined,
+    cap: Capability
+  ): StructuredToolInterface {
+    const logger = this.logger;
+    const ensureConnection = this.ensureConnection.bind(this);
+
+    return tool(
+      async (input: unknown): Promise<string> => {
+        // DEBUG: log tool invocation (remove after POC stabilizes)
+        logger.debug(
+          `[a2a] invoking ${remoteName}${skillId ? `:${skillId}` : ''}`
+        );
+
+        const message = coerceInputToA2AMessage(input, skillId);
+        const conn = await ensureConnection(remoteName);
+        const task = await conn.client.sendTask({
+          id: generateRpcId(),
+          message,
+        });
+
+        try {
+          return extractTaskText(task);
+        } catch (err) {
+          throw new Error(
+            `A2A ${remoteName}${skillId ? `:${skillId}` : ''} failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      },
+      {
+        name: cap.name,
+        description: cap.description,
+        schema: (cap.schema as object) ?? MESSAGE_INPUT_SCHEMA,
+        responseFormat: 'content',
+      }
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers exported for testing
+// ---------------------------------------------------------------------------
+
+// CAPABILITY_NAME_SEPARATOR + formatCapabilityName live in the shared
+// `@/providers/capabilityNaming` module so every provider uses the same
+// encoding. Re-exported here for backward-compatible imports from the
+// A2A barrel.
+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 function parseCapabilityName(
+  name: string
+): { remoteName: string; skillId?: string } | null {
+  const parsed = parseSharedName(name);
+  if (!parsed) return null;
+  return {
+    remoteName: parsed.sourceName,
+    skillId: parsed.itemName,
+  };
+}
+
+/** Derive a Capability from a skill entry on the agent card. */
+export function skillToCapability(
+  remoteName: string,
+  skill: A2ASkill
+): Capability {
+  return {
+    kind: CapabilityKind.A2A,
+    name: formatCapabilityName(remoteName, skill.id),
+    description: skill.description || skill.name || skill.id,
+    schema: MESSAGE_INPUT_SCHEMA,
+    authConfig: [],
+    metadata: {
+      category: 'a2a',
+      tags: [remoteName, ...(skill.tags ?? [])],
+    },
+  };
+}
+
+/**
+ * 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 const MESSAGE_INPUT_SCHEMA = {
+  type: 'object',
+  properties: {
+    message: {
+      type: 'string',
+      description:
+        'Instruction or question to send to the remote agent as a user message.',
+    },
+  },
+  required: ['message'],
+} as const;
+
+/**
+ * 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 function coerceInputToA2AMessage(
+  input: unknown,
+  skillId?: string
+): { role: 'user'; parts: Array<{ type: 'text'; text: string }> } {
+  let text: string;
+  if (typeof input === 'string') {
+    text = input;
+  } else if (input && typeof input === 'object' && 'message' in input) {
+    const val = (input as { message: unknown }).message;
+    text = typeof val === 'string' ? val : JSON.stringify(val);
+  } else {
+    text = JSON.stringify(input);
+  }
+  if (skillId) {
+    text = `[skill: ${skillId}]\n${text}`;
+  }
+  return { role: 'user', parts: [{ type: 'text', text }] };
+}