getToolkits method

Future<List<Toolkit>> getToolkits(ToolContext context, List<RequiredToolkit> remoteToolkits)

Implementation

Future<List<Toolkit>> getToolkits(
  ToolContext context,
  List<RequiredToolkit> remoteToolkits,
) async {
  final Participant? caller = context.caller;
  final Participant? onBehalfOf = context.onBehalfOf;

  Participant? toolTarget = caller;
  if (onBehalfOf != null) {
    toolTarget = onBehalfOf;
  }

  final room = this.room;

  final Map<String, ToolkitDescription> toolkitsByName = {};
  final List<Toolkit> resolvedToolkits = [];

  final visibleToolkits = await room.agents.listToolkits(
    participantId: toolTarget?.id,
  );
  for (final tk in visibleToolkits) {
    toolkitsByName[tk.name] = tk;
  }

  for (final requiredToolkit in remoteToolkits) {
    final tk = toolkitsByName[requiredToolkit.name];
    if (tk == null) {
      if (onBehalfOf != null) {
        throw RoomServerException(
          'unable to get toolkit ${requiredToolkit.name} '
          'on behalf of $onBehalfOf',
        );
      } else {
        throw RoomServerException(
          'unable to get toolkit ${requiredToolkit.name} '
          'for caller ${caller?.id}',
        );
      }
    }

    final List<RoomTool> roomTools = [];

    if (requiredToolkit.tools == null) {
      // Expose all tools
      for (final ToolDescription td in tk.tools) {
        roomTools.add(
          RoomTool(
            onBehalfOfId: toolTarget?.id,
            participantId: toolTarget?.id,
            toolkitName: tk.name,
            name: td.name,
            description: td.description,
            inputSchema: td.inputSchema,
            title: td.title,
            thumbnailUrl: td.thumbnailUrl,
            defs: td.defs,
          ),
        );
      }
    } else {
      // Only specific tools from this toolkit
      final Map<String, ToolDescription> toolsByName = {
        for (final td in tk.tools) td.name: td,
      };

      for (final String requiredToolName in requiredToolkit.tools!) {
        final td = toolsByName[requiredToolName];
        if (td == null) {
          throw RoomServerException(
            'unable to locate required tool $requiredToolName '
            'in toolkit ${requiredToolkit.name}',
          );
        }

        roomTools.add(
          RoomTool(
            onBehalfOfId: toolTarget?.id,
            participantId: toolTarget?.id,
            toolkitName: tk.name,
            name: td.name,
            description: td.description,
            inputSchema: td.inputSchema,
            title: td.title,
            thumbnailUrl: td.thumbnailUrl,
            defs: td.defs,
          ),
        );
      }
    }

    resolvedToolkits.add(
      RoomToolkit(
        name: tk.name,
        title: tk.title,
        description: tk.description,
        thumbnailUrl: tk.thumbnailUrl,
        tools: roomTools,
      ),
    );
  }

  return resolvedToolkits;
}