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

package/src/specs/agent-handoffs-bedrock.integration.test.ts

@@ -1,415 +0,0 @@
-/**
- * Integration test: Agent Handoff with Bedrock
- *
- * Verifies end-to-end that:
- * 1. Handoff tool descriptions are enriched with agent name + description
- * 2. The LLM (Bedrock Claude) can see and use these descriptions to route correctly
- * 3. The handoff actually transfers control to the correct agent
- *
- * Requires: BEDROCK_AWS_ACCESS_KEY_ID, BEDROCK_AWS_SECRET_ACCESS_KEY, BEDROCK_AWS_REGION
- */
-import { config } from 'dotenv';
-import { resolve } from 'path';
-// Load local .env first; optionally fall back to a host-provided env file
-// pointed at by AGENTS_TEST_ENV_PATH.
-config();
-if (process.env.AGENTS_TEST_ENV_PATH) {
-  config({
-    path: resolve(process.env.AGENTS_TEST_ENV_PATH),
-    override: false,
-  });
-}
-
-import { HumanMessage, ToolMessage } from '@langchain/core/messages';
-import type { RunnableConfig } from '@langchain/core/runnables';
-import type * as t from '@/types';
-import { Providers, Constants, GraphEvents, EdgeType } from '@/common';
-import { StandardGraph } from '@/graphs/Graph';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { Run } from '@/run';
-
-const bedrockRegion =
-  process.env.BEDROCK_AWS_REGION != null &&
-  process.env.BEDROCK_AWS_REGION !== ''
-    ? process.env.BEDROCK_AWS_REGION
-    : process.env.BEDROCK_AWS_DEFAULT_REGION;
-const hasBedrock =
-  process.env.BEDROCK_AWS_ACCESS_KEY_ID != null &&
-  process.env.BEDROCK_AWS_ACCESS_KEY_ID !== '' &&
-  process.env.BEDROCK_AWS_SECRET_ACCESS_KEY != null &&
-  process.env.BEDROCK_AWS_SECRET_ACCESS_KEY !== '' &&
-  bedrockRegion != null &&
-  bedrockRegion !== '';
-
-const describeIf = hasBedrock ? describe : describe.skip;
-
-/** Helper to safely get tool description from tool object */
-const getToolDescription = (tool: t.GraphTools[0]): string | undefined => {
-  return (tool as { description?: string }).description;
-};
-
-/** Helper to safely get tool name from tool object */
-const getToolName = (tool: t.GraphTools[0]): string | undefined => {
-  return (tool as { name?: string }).name;
-};
-
-/** Helper to find tool by name */
-const findToolByName = (
-  tools: t.GraphTools | undefined,
-  name: string
-): t.GraphTools[0] | undefined => {
-  return tools?.find((tool) => getToolName(tool) === name);
-};
-
-describeIf('Agent Handoff E2E with Bedrock', () => {
-  jest.setTimeout(120000);
-
-  const bedrockOptions = {
-    model: 'us.anthropic.claude-3-5-haiku-20241022-v1:0',
-    region:
-      bedrockRegion != null && bedrockRegion !== ''
-        ? bedrockRegion
-        : 'us-east-1',
-    credentials: {
-      accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
-      secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
-    },
-  };
-
-  const createBedrockAgent = (
-    agentId: string,
-    name: string,
-    description: string,
-    instructions: string
-  ): t.AgentInputs => ({
-    agentId,
-    name,
-    description,
-    provider: Providers.BEDROCK,
-    clientOptions: bedrockOptions,
-    instructions,
-    maxContextTokens: 28000,
-  });
-
-  describe('Tool Description Enrichment (no edge.description)', () => {
-    it('should generate tool descriptions from agent name + description when edge has no description', async () => {
-      const agents: t.AgentInputs[] = [
-        createBedrockAgent(
-          'supervisor_abc123',
-          'Supervisor',
-          'Routes requests to specialists',
-          'You are a supervisor. Route requests to the appropriate specialist.'
-        ),
-        createBedrockAgent(
-          'agent_W47hBnn2RoVZEOy5595GC',
-          'Sales Expert',
-          'Handles product pricing, quotes, and purchase orders for enterprise clients',
-          'You are a sales expert.'
-        ),
-        createBedrockAgent(
-          'agent_X92kLmn4TpQR8vw3221HD',
-          'Technical Support',
-          'Troubleshoots technical issues, resolves bugs, and handles escalations',
-          'You are a technical support agent.'
-        ),
-      ];
-
-      // Edges WITHOUT explicit descriptions - simulates what happens in production
-      // when users add handoffs through the UI without typing descriptions
-      const edges: t.GraphEdge[] = [
-        {
-          from: 'supervisor_abc123',
-          to: 'agent_W47hBnn2RoVZEOy5595GC',
-          edgeType: EdgeType.TRANSFER,
-          // No description - should auto-generate from agent name + description
-        },
-        {
-          from: 'supervisor_abc123',
-          to: 'agent_X92kLmn4TpQR8vw3221HD',
-          edgeType: EdgeType.TRANSFER,
-          // No description
-        },
-      ];
-
-      const run = await Run.create({
-        runId: `bedrock-handoff-desc-${Date.now()}`,
-        graphConfig: {
-          type: 'multi-agent',
-          agents,
-          edges,
-        },
-        returnContent: true,
-      });
-
-      const supervisorContext = (run.Graph as StandardGraph).agentContexts.get(
-        'supervisor_abc123'
-      );
-
-      // Verify the handoff tools have enriched descriptions
-      const salesTool = findToolByName(
-        supervisorContext?.graphTools,
-        `${Constants.LC_TRANSFER_TO_}agent_W47hBnn2RoVZEOy5595GC`
-      );
-      const supportTool = findToolByName(
-        supervisorContext?.graphTools,
-        `${Constants.LC_TRANSFER_TO_}agent_X92kLmn4TpQR8vw3221HD`
-      );
-
-      expect(salesTool).toBeDefined();
-      expect(supportTool).toBeDefined();
-
-      const salesDesc = getToolDescription(salesTool!);
-      const supportDesc = getToolDescription(supportTool!);
-
-      // CRITICAL: Descriptions must NOT be just "Transfer control to agent 'agent_W47hBnn...'"
-      // They must include the human-readable name and description
-      expect(salesDesc).toContain('Sales Expert');
-      expect(salesDesc).toContain('pricing');
-      expect(salesDesc).not.toContain('agent_W47hBnn2RoVZEOy5595GC');
-
-      expect(supportDesc).toContain('Technical Support');
-      expect(supportDesc).toContain('Troubleshoots');
-      expect(supportDesc).not.toContain('agent_X92kLmn4TpQR8vw3221HD');
-
-      /* eslint-disable no-console */
-      console.log('[PASS] Sales tool description:', salesDesc);
-      console.log('[PASS] Support tool description:', supportDesc);
-      /* eslint-enable no-console */
-    });
-  });
-
-  describe('Live Bedrock Handoff Routing', () => {
-    it('should route a sales question to the Sales Expert agent', async () => {
-      const agents: t.AgentInputs[] = [
-        createBedrockAgent(
-          'router',
-          'Router',
-          'Routes user requests to specialists',
-          `You are a request router. You must analyze the user's message and transfer to the appropriate specialist.
-
-          IMPORTANT: Do NOT answer the question yourself. You MUST use one of your transfer tools to hand off to a specialist.
-          Pick the specialist whose description best matches the user's request.`
-        ),
-        createBedrockAgent(
-          'sales_agent',
-          'Sales Expert',
-          'Handles product pricing, quotes, and purchase orders',
-          'You are a sales expert. Answer questions about pricing and products. Be concise.'
-        ),
-        createBedrockAgent(
-          'support_agent',
-          'Technical Support',
-          'Troubleshoots technical issues and resolves bugs',
-          'You are technical support. Help with technical problems. Be concise.'
-        ),
-      ];
-
-      const edges: t.GraphEdge[] = [
-        { from: 'router', to: 'sales_agent', edgeType: EdgeType.TRANSFER },
-        { from: 'router', to: 'support_agent', edgeType: EdgeType.TRANSFER },
-      ];
-
-      const { contentParts: _contentParts, aggregateContent } =
-        createContentAggregator();
-      const customHandlers = {
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-        [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-        [GraphEvents.ON_RUN_STEP]: {
-          handle: (event: string, data: t.StreamEventData): void => {
-            aggregateContent({
-              event: event as GraphEvents,
-              data: data as t.RunStep,
-            });
-          },
-        },
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-          handle: (event: string, data: t.StreamEventData): void => {
-            aggregateContent({
-              event: event as GraphEvents,
-              data: data as unknown as { result: t.ToolEndEvent },
-            });
-          },
-        },
-        [GraphEvents.ON_MESSAGE_DELTA]: {
-          handle: (event: string, data: t.StreamEventData): void => {
-            aggregateContent({
-              event: event as GraphEvents,
-              data: data as t.MessageDeltaEvent,
-            });
-          },
-        },
-      };
-
-      const run = await Run.create({
-        runId: `bedrock-live-handoff-${Date.now()}`,
-        graphConfig: {
-          type: 'multi-agent',
-          agents,
-          edges,
-        },
-        customHandlers,
-        returnContent: true,
-      });
-
-      const config: Partial<RunnableConfig> & {
-        version: 'v1' | 'v2';
-        streamMode: string;
-      } = {
-        configurable: { thread_id: 'bedrock-handoff-test' },
-        streamMode: 'values',
-        version: 'v2',
-      };
-
-      // Send a sales-related question
-      const messages = [
-        new HumanMessage('What is the pricing for your enterprise plan?'),
-      ];
-
-      await run.processStream({ messages }, config);
-
-      const finalMessages = run.getRunMessages();
-      expect(finalMessages).toBeDefined();
-      expect(finalMessages!.length).toBeGreaterThan(1);
-
-      // Verify the handoff happened to the sales agent (not support)
-      const toolMessages = finalMessages!.filter(
-        (msg) => msg.getType() === 'tool'
-      ) as ToolMessage[];
-
-      const salesHandoff = toolMessages.find(
-        (msg) => msg.name === `${Constants.LC_TRANSFER_TO_}sales_agent`
-      );
-      const supportHandoff = toolMessages.find(
-        (msg) => msg.name === `${Constants.LC_TRANSFER_TO_}support_agent`
-      );
-
-      expect(salesHandoff).toBeDefined();
-      expect(supportHandoff).toBeUndefined();
-
-      /* eslint-disable no-console */
-      console.log('[PASS] Router correctly handed off to Sales Expert');
-      console.log('[PASS] Handoff tool message:', salesHandoff?.content);
-      /* eslint-enable no-console */
-
-      // Verify the sales agent actually responded
-      const aiMessages = finalMessages!.filter((msg) => msg.getType() === 'ai');
-      expect(aiMessages.length).toBeGreaterThanOrEqual(2); // Router + Sales responses
-    });
-
-    it('should route a technical question to the Support agent', async () => {
-      const agents: t.AgentInputs[] = [
-        createBedrockAgent(
-          'router',
-          'Router',
-          'Routes user requests to specialists',
-          `You are a request router. You must analyze the user's message and transfer to the appropriate specialist.
-
-          IMPORTANT: Do NOT answer the question yourself. You MUST use one of your transfer tools to hand off to a specialist.
-          Pick the specialist whose description best matches the user's request.`
-        ),
-        createBedrockAgent(
-          'sales_agent',
-          'Sales Expert',
-          'Handles product pricing, quotes, and purchase orders',
-          'You are a sales expert. Answer questions about pricing. Be concise.'
-        ),
-        createBedrockAgent(
-          'support_agent',
-          'Technical Support',
-          'Troubleshoots technical issues, resolves bugs, and handles error messages',
-          'You are technical support. Help with technical problems. Be concise.'
-        ),
-      ];
-
-      const edges: t.GraphEdge[] = [
-        { from: 'router', to: 'sales_agent', edgeType: EdgeType.TRANSFER },
-        { from: 'router', to: 'support_agent', edgeType: EdgeType.TRANSFER },
-      ];
-
-      const { contentParts: _contentParts, aggregateContent } =
-        createContentAggregator();
-      const customHandlers = {
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-        [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-        [GraphEvents.ON_RUN_STEP]: {
-          handle: (event: string, data: t.StreamEventData): void => {
-            aggregateContent({
-              event: event as GraphEvents,
-              data: data as t.RunStep,
-            });
-          },
-        },
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-          handle: (event: string, data: t.StreamEventData): void => {
-            aggregateContent({
-              event: event as GraphEvents,
-              data: data as unknown as { result: t.ToolEndEvent },
-            });
-          },
-        },
-        [GraphEvents.ON_MESSAGE_DELTA]: {
-          handle: (event: string, data: t.StreamEventData): void => {
-            aggregateContent({
-              event: event as GraphEvents,
-              data: data as t.MessageDeltaEvent,
-            });
-          },
-        },
-      };
-
-      const run = await Run.create({
-        runId: `bedrock-live-handoff-support-${Date.now()}`,
-        graphConfig: {
-          type: 'multi-agent',
-          agents,
-          edges,
-        },
-        customHandlers,
-        returnContent: true,
-      });
-
-      const config: Partial<RunnableConfig> & {
-        version: 'v1' | 'v2';
-        streamMode: string;
-      } = {
-        configurable: { thread_id: 'bedrock-handoff-support-test' },
-        streamMode: 'values',
-        version: 'v2',
-      };
-
-      // Send a technical question
-      const messages = [
-        new HumanMessage(
-          'I am getting an error 500 when trying to login. The page crashes after entering my password.'
-        ),
-      ];
-
-      await run.processStream({ messages }, config);
-
-      const finalMessages = run.getRunMessages();
-      expect(finalMessages).toBeDefined();
-
-      const toolMessages = finalMessages!.filter(
-        (msg) => msg.getType() === 'tool'
-      ) as ToolMessage[];
-
-      const supportHandoff = toolMessages.find(
-        (msg) => msg.name === `${Constants.LC_TRANSFER_TO_}support_agent`
-      );
-      const salesHandoff = toolMessages.find(
-        (msg) => msg.name === `${Constants.LC_TRANSFER_TO_}sales_agent`
-      );
-
-      expect(supportHandoff).toBeDefined();
-      expect(salesHandoff).toBeUndefined();
-
-      /* eslint-disable no-console */
-      console.log('[PASS] Router correctly handed off to Technical Support');
-      console.log('[PASS] Handoff tool message:', supportHandoff?.content);
-      /* eslint-enable no-console */
-    });
-  });
-});

package/src/tools/artifacts/__tests__/tool.test.ts

@@ -1,259 +0,0 @@
-/**
- * Unit tests for the artifact_tool + content_reader library factories.
- *
- * The factories are thin dispatchers — their job is:
- *   1. Resolve scope from runnableConfig (error if missing)
- *   2. Optionally self-heal content_id via the resolver
- *   3. Validate per-action required args
- *   4. Route to the runtime's handler, propagate errors
- *
- * We verify each of those paths here with mock handlers.
- */
-
-import { createArtifactTool, createContentReaderTool } from '../tool';
-import type {
-  ArtifactWriteHandlers,
-  ContentReadHandlers,
-  ArtifactToolScope,
-  ArtifactToolResult,
-  ContentIdResolver,
-} from '../types';
-
-function makeScope(): ArtifactToolScope {
-  return { conversationId: 'conv-1', userId: 'user-1' };
-}
-
-function makeWriteHandlers(): ArtifactWriteHandlers & {
-  _calls: Array<{ action: string; args: unknown; scope: ArtifactToolScope }>;
-} {
-  const calls: Array<{
-    action: string;
-    args: unknown;
-    scope: ArtifactToolScope;
-  }> = [];
-  return {
-    _calls: calls,
-    write: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'write', args, scope });
-      return ['wrote it', { id: 'new-id' }];
-    }),
-    edit: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'edit', args, scope });
-      return ['edited', {}];
-    }),
-    verify: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'verify', args, scope });
-      return ['verified', {}];
-    }),
-    delete: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'delete', args, scope });
-      return ['deleted', {}];
-    }),
-  };
-}
-
-function makeReadHandlers(): ContentReadHandlers & {
-  _calls: Array<{ action: string; args: unknown; scope: ArtifactToolScope }>;
-} {
-  const calls: Array<{
-    action: string;
-    args: unknown;
-    scope: ArtifactToolScope;
-  }> = [];
-  return {
-    _calls: calls,
-    read: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'read', args, scope });
-      return ['read-output', {}];
-    }),
-    search: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'search', args, scope });
-      return ['search-output', {}];
-    }),
-    list: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'list', args, scope });
-      return ['list-output', {}];
-    }),
-    info: jest.fn(async (args, scope): Promise<ArtifactToolResult> => {
-      calls.push({ action: 'info', args, scope });
-      return ['info-output', {}];
-    }),
-  };
-}
-
-describe('createArtifactTool', () => {
-  it('returns a scope error when getScope returns null', async () => {
-    const handlers = makeWriteHandlers();
-    const t = createArtifactTool({
-      handlers,
-      getScope: () => null,
-    });
-    const result = await t.invoke({ action: 'write', content: 'x' });
-    const text = Array.isArray(result) ? String(result[0]) : String(result);
-    expect(text).toMatch(/no conversation context/i);
-  });
-
-  it('dispatches write to handlers.write with resolved args + scope', async () => {
-    const handlers = makeWriteHandlers();
-    const t = createArtifactTool({
-      handlers,
-      getScope: makeScope,
-    });
-    await t.invoke({ action: 'write', content: 'hello', name: 'doc.md' });
-    expect(handlers.write).toHaveBeenCalledTimes(1);
-    expect(handlers._calls[0].args).toEqual(
-      expect.objectContaining({
-        action: 'write',
-        content: 'hello',
-        name: 'doc.md',
-      })
-    );
-    expect(handlers._calls[0].scope).toEqual(
-      expect.objectContaining({ conversationId: 'conv-1' })
-    );
-  });
-
-  it('rejects write without content', async () => {
-    const handlers = makeWriteHandlers();
-    const t = createArtifactTool({
-      handlers,
-      getScope: makeScope,
-    });
-    const result = await t.invoke({ action: 'write' });
-    const text = Array.isArray(result) ? String(result[0]) : String(result);
-    expect(text).toMatch(/write requires content/i);
-    expect(handlers.write).not.toHaveBeenCalled();
-  });
-
-  it('rejects edit/verify/delete without content_id', async () => {
-    const handlers = makeWriteHandlers();
-    const t = createArtifactTool({
-      handlers,
-      getScope: makeScope,
-    });
-    const e = await t.invoke({ action: 'edit', old_str: 'a', new_str: 'b' });
-    expect(String(Array.isArray(e) ? e[0] : e)).toMatch(
-      /edit requires content_id/i
-    );
-    const v = await t.invoke({ action: 'verify' });
-    expect(String(Array.isArray(v) ? v[0] : v)).toMatch(
-      /verify requires content_id/i
-    );
-    const d = await t.invoke({ action: 'delete' });
-    expect(String(Array.isArray(d) ? d[0] : d)).toMatch(
-      /delete requires content_id/i
-    );
-  });
-
-  it('applies the resolver before dispatching to handler', async () => {
-    const handlers = makeWriteHandlers();
-    const resolver: ContentIdResolver = {
-      resolve: jest.fn(async (id) => ({
-        resolvedId: `canonical:${id}`,
-        resolvedName: 'X',
-      })),
-    };
-    const t = createArtifactTool({
-      handlers,
-      getScope: makeScope,
-      resolver,
-    });
-    await t.invoke({
-      action: 'edit',
-      content_id: 'nickname',
-      old_str: 'a',
-      new_str: 'b',
-    });
-    expect(handlers._calls[0].args).toEqual(
-      expect.objectContaining({ content_id: 'canonical:nickname' })
-    );
-  });
-
-  it('catches handler exceptions and returns them as tool errors', async () => {
-    const handlers = makeWriteHandlers();
-    handlers.write = jest.fn(async () => {
-      throw new Error('s3 unavailable');
-    });
-    const t = createArtifactTool({
-      handlers,
-      getScope: makeScope,
-    });
-    const result = await t.invoke({ action: 'write', content: 'x' });
-    const text = Array.isArray(result) ? String(result[0]) : String(result);
-    expect(text).toMatch(/s3 unavailable/);
-  });
-
-  it('honors descriptionOverride for host-specific guidance', async () => {
-    const handlers = makeWriteHandlers();
-    const t = createArtifactTool({
-      handlers,
-      getScope: makeScope,
-      descriptionOverride: 'HOST-BRAND-GUIDE',
-    });
-    expect(t.description).toBe('HOST-BRAND-GUIDE');
-  });
-});
-
-describe('createContentReaderTool', () => {
-  it('dispatches list with no content_id required', async () => {
-    const handlers = makeReadHandlers();
-    const t = createContentReaderTool({
-      handlers,
-      getScope: makeScope,
-    });
-    await t.invoke({ action: 'list' });
-    expect(handlers.list).toHaveBeenCalledTimes(1);
-  });
-
-  it('rejects read/info/search without content_id', async () => {
-    const handlers = makeReadHandlers();
-    const t = createContentReaderTool({
-      handlers,
-      getScope: makeScope,
-    });
-    const r = await t.invoke({ action: 'read' });
-    expect(String(Array.isArray(r) ? r[0] : r)).toMatch(
-      /read requires content_id/i
-    );
-    const i = await t.invoke({ action: 'info' });
-    expect(String(Array.isArray(i) ? i[0] : i)).toMatch(
-      /info requires content_id/i
-    );
-    const s = await t.invoke({ action: 'search', pattern: 'p' });
-    expect(String(Array.isArray(s) ? s[0] : s)).toMatch(
-      /search requires content_id/i
-    );
-  });
-
-  it('rejects search without pattern even when content_id is given', async () => {
-    const handlers = makeReadHandlers();
-    const t = createContentReaderTool({
-      handlers,
-      getScope: makeScope,
-    });
-    const result = await t.invoke({ action: 'search', content_id: 'x' });
-    const text = Array.isArray(result) ? String(result[0]) : String(result);
-    expect(text).toMatch(/search requires pattern/i);
-  });
-
-  it('passes read pagination args through to the handler', async () => {
-    const handlers = makeReadHandlers();
-    const t = createContentReaderTool({
-      handlers,
-      getScope: makeScope,
-    });
-    await t.invoke({
-      action: 'read',
-      content_id: 'c-1',
-      start_line: 10,
-      end_line: 50,
-    });
-    expect(handlers._calls[0].args).toEqual(
-      expect.objectContaining({
-        content_id: 'c-1',
-        start_line: 10,
-        end_line: 50,
-      })
-    );
-  });
-});

package/src/tools/artifacts/index.ts

@@ -1,33 +0,0 @@
-export {
-  createArtifactTool,
-  createContentReaderTool,
-  ARTIFACT_TOOL_NAME,
-  CONTENT_READER_NAME,
-  ARTIFACT_WRITE_ACTIONS,
-  CONTENT_READ_ACTIONS,
-} from './tool';
-export {
-  artifactToolSchema,
-  contentReaderSchema,
-  type ArtifactToolInput,
-  type ContentReaderInput,
-} from './schema';
-export type {
-  ArtifactToolScope,
-  ArtifactToolResult,
-  ArtifactToolLogger,
-  ArtifactToolBaseConfig,
-  ArtifactToolConfig,
-  ContentReaderToolConfig,
-  ArtifactWriteHandlers,
-  ContentReadHandlers,
-  ContentIdResolver,
-  WriteArgs,
-  EditArgs,
-  VerifyArgs,
-  DeleteArgs,
-  ReadArgs,
-  SearchArgs,
-  ListArgs,
-  InfoArgs,
-} from './types';